Delete Node at Specific Position in DSA Javascript - Execution Trace

Concept Flow - Delete Node at Specific Position

Start at head

↓

Check if position is 0

|Yes↓

Delete head node

No↓

Traverse to node before position

↓

Check if next node exists

|No↓

Position invalid, stop

Yes↓

Delete node at position

Start from the head, if position is zero delete head. Otherwise, move to the node before the target position, then delete the next node if it exists.

Execution Sample

DSA Javascript

function deleteNode(head, position) {
  if (position === 0) return head.next;
  let current = head;
  for (let i = 0; i < position - 1; i++) {
    if (!current.next) return head;
    current = current.next;
  }
  if (current.next) current.next = current.next.next;
  return head;
}

Deletes the node at the given position in a singly linked list and returns the updated head.

Execution Table

Step	position	current node value	Action	List state after action
1	2	1	Check if position is 0 (No)	1 -> 2 -> 3 -> 4 -> 5 -> null
2	2	1	Traverse to node before position (i=0)	1 -> 2 -> 3 -> 4 -> 5 -> null
3	2	2	Traverse to node before position (i=1)	1 -> 2 -> 3 -> 4 -> 5 -> null
4	2	2	Delete node at position 2 (node with value 3)	1 -> 2 -> 4 -> 5 -> null
5	2	2	Return updated head	1 -> 2 -> 4 -> 5 -> null

💡 Traversal stops after reaching node before position; node at position deleted by skipping it.

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	Final
position	2	2	2	2	2
current	1 (head)	1	2	2	2
head	1	1	1	1	1

Key Moments - 3 Insights

Why do we stop traversal at position - 1 and not at position?

Because we need to change the next pointer of the node before the target to skip the target node. See execution_table rows 2 and 3 where current moves to node before position.

What happens if position is 0?

The head node is deleted by returning head.next immediately, as shown in execution_table row 1 where position 0 check is done.

What if the position is beyond the list length?

Traversal stops early when current.next is null, and the original list is returned unchanged. This is checked in the for loop condition in the code and reflected in execution_table row 2.

Visual Quiz - 3 Questions

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

A 1

B 2

C 3

D 4

💡 Hint

Check the 'current node value' column in execution_table row 3.

At which step does the node with value 3 get deleted?

A Step 2

B Step 3

C Step 4

D Step 5

💡 Hint

Look at the 'Action' column in execution_table for the deletion action.

If position was 0, what would the list look like after deletion?

A 2 -> 3 -> 4 -> 5 -> null

B 1 -> 3 -> 4 -> 5 -> null

C 1 -> 2 -> 4 -> 5 -> null

D 1 -> 2 -> 3 -> 4 -> 5 -> null

💡 Hint

Deleting at position 0 removes the head node, so the list starts from the second node.

Concept Snapshot

Delete Node at Specific Position:
- If position is 0, remove head by returning head.next.
- Else, move to node before position.
- Change its next pointer to skip the node at position.
- If position invalid, return original list.
- Returns updated head of the list.

Full Transcript

This concept shows how to delete a node at a specific position in a singly linked list. We start by checking if the position is zero, which means deleting the head node. If so, we return the next node as the new head. Otherwise, we move through the list to the node just before the target position. If this node exists and has a next node, we skip the next node by linking to the node after it. If the position is beyond the list length, no deletion happens and the original list is returned. The code returns the updated head after deletion.

Practice

1. What happens when you delete a node at position 0 in a singly linked list?

easy

A. The head pointer moves to the next node, effectively removing the first node.

B. The last node is removed from the list.

C. The list becomes empty regardless of its size.

D. The node at position 1 is deleted instead.

Solution

1. Step 1: Understand position 0 in linked list

   Position 0 refers to the first node, also called the head.

2. Step 2: Effect of deleting head node

   Deleting the head means moving the head pointer to the next node, removing the first node from the list.

3. Final Answer:

   The head pointer moves to the next node, effectively removing the first node. -> Option A

4. Quick Check:

   Deleting position 0 removes the first node [OK]

Hint: Deleting position 0 means changing the head pointer [OK]

Common Mistakes:

• Thinking the last node is deleted instead
• Assuming the list becomes empty always
• Deleting the wrong node position

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

easy

A. head = head[pos + 1];

B. if (pos === 0) head = head.next;

C. delete head[pos];

D. head.next = null;

Solution

1. Step 1: Check deletion at position 0

   Deleting at position 0 means moving head to head.next.

2. Step 2: Validate syntax correctness

   if (pos === 0) head = head.next; correctly assigns head to head.next. Other options misuse syntax or do not delete the node properly.

3. Final Answer:

   if (pos === 0) head = head.next; -> Option B

4. Quick Check:

   Correct syntax for deleting head node is head = head.next [OK]

Hint: To delete head, assign head = head.next [OK]

Common Mistakes:

• Using delete keyword incorrectly on linked list nodes
• Assigning head.next to null without updating head
• Accessing nodes with array-like syntax

3. Given the linked list: 10 -> 20 -> 30 -> 40 -> null, what is the list after deleting the node at position 2?

medium

A. 10 -> 20 -> 30 -> null

B. 10 -> 30 -> 40 -> null

C. 20 -> 30 -> 40 -> null

D. 10 -> 20 -> 40 -> null

Solution

1. Step 1: Identify node at position 2

   Positions start at 0, so position 2 is the third node with value 30.

2. Step 2: Delete node at position 2

   Remove node 30 by linking node 20's next to node 40.

3. Final Answer:

   10 -> 20 -> 40 -> null -> Option D

4. Quick Check:

   Deleted node 30 at position 2 [OK]

Hint: Count from 0, remove node at that index [OK]

Common Mistakes:

• Deleting wrong node by miscounting positions
• Not updating the previous node's next pointer
• Confusing node values with positions

4. What is the error in the following code snippet for deleting a node at position pos in a singly linked list?

function deleteNode(head, pos) {
  let current = head;
  for (let i = 0; i < pos - 1; i++) {
    current = current.next;
  }
  current.next = current.next.next;
  return head;
}

medium

A. It does not handle deletion when pos is 0 (head node).

B. It incorrectly updates the head pointer.

C. It causes a syntax error due to missing semicolons.

D. It deletes the last node instead of the specified position.

Solution

1. Step 1: Analyze loop for position traversal

   The loop stops at node before position to delete, which is correct for pos > 0.

2. Step 2: Check handling of pos = 0

   When pos is 0, the loop does not run and current is head, but code does not update head pointer, so deletion fails.

3. Final Answer:

   It does not handle deletion when pos is 0 (head node). -> Option A

4. Quick Check:

   Missing head deletion case causes error [OK]

Hint: Always check if deleting head node separately [OK]

Common Mistakes:

• Ignoring edge case when pos is 0
• Assuming loop handles all positions
• Not updating head pointer when needed

5. You have a singly linked list: 5 -> 15 -> 25 -> 35 -> 45 -> null. You want to delete the node at position 4. What will the list look like after deletion? Also, what happens if you try to delete at position 5?

hard

A. After deletion at position 4: 5 -> 15 -> 25 -> 35 -> null; Deleting position 5 causes a runtime error.

B. After deletion at position 4: 5 -> 15 -> 25 -> 35 -> 45 -> null; Deleting position 5 removes the last node.

C. After deletion at position 4: 5 -> 15 -> 25 -> 35 -> null; Deleting position 5 does nothing as it's out of range.

D. After deletion at position 4: 15 -> 25 -> 35 -> 45 -> null; Deleting position 5 removes the head.

Solution

1. Step 1: Identify node at position 4

   Positions start at 0, so position 4 is the fifth node with value 45.

2. Step 2: Delete node at position 4

   Remove node 45 by linking node 35's next to null.

3. Step 3: Consider deletion at position 5

   Position 5 is out of list range (list length is 5), so deletion does nothing safely.

4. Final Answer:

   After deletion at position 4: 5 -> 15 -> 25 -> 35 -> null; Deleting position 5 does nothing as it's out of range. -> Option C

5. Quick Check:

   Deleting last node removes it; out-of-range deletion ignored [OK]

Hint: Deleting out-of-range position does nothing [OK]

Common Mistakes:

• Trying to delete non-existent node causing errors
• Confusing positions and node values
• Not updating previous node's next pointer correctly