Delete Node at End in DSA Javascript - Execution Trace

Concept Flow - Delete Node at End

Start at head

↓

Check if list is empty

|Yes↓

Nothing to delete, EXIT

No↓

Traverse to second last node

↓

Set second last node's next to null

↓

Last node deleted

↓

End

Start from the head, check if list is empty. If not, move to the second last node and remove the last node by setting next to null.

Execution Sample

DSA Javascript

function deleteAtEnd(head) {
  if (!head) return null;
  if (!head.next) return null;
  let current = head;
  while (current.next && current.next.next) {
    current = current.next;
  }
  current.next = null;
  return head;
}

Deletes the last node from a singly linked list and returns the updated head.

Execution Table

Step	Action	Current Node Value	Next Node Value	List State
1	Check if head is null	1	2	1 -> 2 -> 3 -> null
2	Check if head.next is null	1	2	1 -> 2 -> 3 -> null
3	Initialize current = head	1	2	1 -> 2 -> 3 -> null
4	Check current.next.next exists	1	2	1 -> 2 -> 3 -> null
5	Move current to current.next	2	3	1 -> 2 -> 3 -> null
6	Check current.next.next exists	2	3	1 -> 2 -> 3 -> null
7	current.next.next is null, stop loop	2	3	1 -> 2 -> 3 -> null
8	Set current.next = null (delete last node)	2	null	1 -> 2 -> null
9	Return head	1	2	1 -> 2 -> null

💡 Loop stops when current.next.next is null, meaning current is second last node.

Variable Tracker

Variable	Start	After Step 5	After Step 7	Final
head	Node(1)	Node(1)	Node(1)	Node(1)
current	Node(1)	Node(2)	Node(2)	Node(2)

Key Moments - 2 Insights

Why do we check current.next.next instead of current.next in the loop?

We check current.next.next to stop at the second last node, so we can set its next to null and delete the last node. See execution_table step 6 and 7.

What happens if the list has only one node?

If head.next is null, it means only one node exists. We return null to indicate the list becomes empty after deletion. See execution_table step 2.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of 'current' after step 5?

A Node with value 1

B Node with value 2

C Node with value 3

D null

💡 Hint

Check the 'Current Node Value' column at step 5 in execution_table.

At which step does the loop stop because current.next.next is null?

A Step 4

B Step 6

C Step 7

D Step 8

💡 Hint

Look for the step where the loop condition fails in execution_table.

If the list had only one node, what would the function return?

A null

B The same single node

C An error

D The head's next node

💡 Hint

See execution_table step 2 where head.next is null.

Concept Snapshot

Delete Node at End in singly linked list:
- If list empty, return null
- If only one node, return null
- Traverse to second last node
- Set second last node's next to null
- Return updated head

Full Transcript

This visual execution traces deleting the last node from a singly linked list. We start by checking if the list is empty or has only one node. If so, we return null because the list becomes empty after deletion. Otherwise, we traverse the list to find the second last node by checking current.next.next. When current.next.next is null, current is second last node. We then set current.next to null, removing the last node. Finally, we return the head of the updated list. The execution table shows each step with current node values and list state. Variable tracker shows how 'current' moves from head to second last node. Key moments clarify why we check current.next.next and handle single-node lists. The quiz tests understanding of these steps.

Practice

1. What does the operation Delete Node at End do in a singly linked list?

easy

A. Adds a new node at the end of the linked list

B. Removes the first node from the linked list

C. Removes the last node from the linked list

D. Adds a new node at the beginning of the linked list

Solution

1. Step 1: Understand the linked list structure

   A singly linked list is a chain of nodes where each node points to the next node, ending with a node pointing to null.

2. Step 2: Identify what deleting the last node means

   Deleting the last node means removing the node that points to null, effectively shortening the list by one node at the end.

3. Final Answer:

   Removes the last node from the linked list -> Option C

4. Quick Check:

   Delete Node at End = Remove last node [OK]

Hint: Last node points to null; delete it to remove end [OK]

Common Mistakes:

• Confusing delete at end with delete at start
• Thinking it adds a node instead of removing
• Assuming it deletes a middle node

2. Which of the following is the correct syntax to delete the last node in a singly linked list in JavaScript?

easy

A. list.deleteEnd();

B. list.pop();

C. list.deleteNodeAtEnd();

D. list.removeLastNode();

Solution

1. Step 1: Recognize common JavaScript linked list methods

   JavaScript arrays use pop() to remove the last element; custom linked lists often implement similar methods.

2. Step 2: Identify the standard method name

   Among the options, pop() is the standard method name used to remove the last element in many list implementations.

3. Final Answer:

   list.pop(); -> Option B

4. Quick Check:

   pop() removes last element [OK]

Hint: pop() usually removes last element in lists [OK]

Common Mistakes:

• Using non-standard method names
• Confusing delete with remove
• Assuming deleteEnd() is built-in

3. Consider the following JavaScript code for a singly linked list deletion at end:

class Node {
  constructor(data) {
    this.data = data;
    this.next = null;
  }
}

class LinkedList {
  constructor() {
    this.head = null;
  }

  deleteAtEnd() {
    if (!this.head) return null;
    if (!this.head.next) {
      this.head = null;
      return;
    }
    let current = this.head;
    while (current.next.next) {
      current = current.next;
    }
    current.next = null;
  }
}

let list = new LinkedList();
list.head = new Node(1);
list.head.next = new Node(2);
list.head.next.next = new Node(3);
list.deleteAtEnd();

let result = [];
let temp = list.head;
while(temp) {
  result.push(temp.data);
  temp = temp.next;
}
console.log(result);

What will be printed?

medium

A. [1, 2, 3]

B. [2, 3]

C. [1]

D. [1, 2]

Solution

1. Step 1: Understand the initial list and deletion

   The list starts as 1 -> 2 -> 3. The deleteAtEnd() method removes the last node (3).

2. Step 2: Trace the deletion and final list

   After deletion, the list becomes 1 -> 2. The loop collects these values into the array [1, 2].

3. Final Answer:

   [1, 2] -> Option D

4. Quick Check:

   Deleting last node removes 3, leaving [1, 2] [OK]

Hint: Deleting end removes last node, so last value drops [OK]

Common Mistakes:

• Forgetting to update the second last node's next to null
• Assuming the head changes incorrectly
• Not handling single-node list case

4. The following code tries to delete the last node of a singly linked list but causes an error:

deleteAtEnd() {
  let current = this.head;
  while (current.next) {
    current = current.next;
  }
  current = null;
}

What is the main problem?

medium

A. It sets the local variable to null but does not update the list

B. It does not handle empty list case

C. It deletes the head node instead of last node

D. It causes infinite loop

Solution

1. Step 1: Analyze the loop and pointer update

   The loop moves current to the last node, but setting current = null only changes the local variable, not the list's links.

2. Step 2: Understand why the last node is not removed

   To remove the last node, the previous node's next must be set to null. This code misses that step.

3. Final Answer:

   It sets the local variable to null but does not update the list -> Option A

4. Quick Check:

   Local variable null doesn't remove node [OK]

Hint: Update previous node's next, not local pointer [OK]

Common Mistakes:

• Setting current to null instead of previous.next
• Not checking for single-node list
• Ignoring empty list case

5. You have a singly linked list with nodes: 10 -> 20 -> 30 -> 40. You want to delete the last node and then add a new node with value 50 at the end. Which sequence of operations correctly achieves this?

hard

A. Call deleteAtEnd(), then call addAtEnd(50)

B. Call addAtEnd(50), then call deleteAtEnd()

C. Call deleteAtEnd() twice, then addAtEnd(50)

D. Call deleteAtEnd(), then addAtStart(50)

Solution

1. Step 1: Delete the last node

   Calling deleteAtEnd() removes the node with value 40, list becomes 10 -> 20 -> 30.

2. Step 2: Add new node at the end

   Calling addAtEnd(50) adds a new node with value 50 at the end, list becomes 10 -> 20 -> 30 -> 50.

3. Final Answer:

   Call deleteAtEnd(), then call addAtEnd(50) -> Option A

4. Quick Check:

   Delete last then add new last node [OK]

Hint: Delete last first, then add new node at end [OK]

Common Mistakes:

• Adding before deleting causes wrong order
• Deleting twice removes too many nodes
• Adding at start changes list order