Delete Node at Specific Position in DSA Go - 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 out of range, stop

Yes↓

Change next pointer to skip node

Start from the head, if position is zero delete head. Otherwise, move to node before position, then skip the node at position by changing pointers.

Execution Sample

DSA Go

func deleteAtPosition(head *Node, pos int) *Node {
  if pos == 0 {
    return head.next
  }
  curr := head
  for i := 0; i < pos-1 && curr != nil; i++ {
    curr = curr.next
  }
  if curr == nil || curr.next == nil {
    return head
  }
  curr.next = curr.next.next
  return head
}

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

Execution Table

Step	pos	i	curr Node Value	Condition	Action	List State
1	2	-	1	pos == 0? False	Skip head deletion	1 -> 2 -> 3 -> 4 -> null
2	2	0	1	i < pos-1 and curr != nil? True	Move curr to next	1 -> 2 -> 3 -> 4 -> null
3	2	1	2	i < pos-1 and curr != nil? False	Stop loop	1 -> 2 -> 3 -> 4 -> null
4	2	-	2	curr == nil or curr.next == nil? False	Proceed to delete	1 -> 2 -> 3 -> 4 -> null
5	2	-	2	Delete node at pos by skipping	curr.next = curr.next.next	1 -> 2 -> 4 -> null
6	2	-	-	-	Return head	1 -> 2 -> 4 -> null
7	5	-	1	pos == 0? False	Skip head deletion	1 -> 2 -> 3 -> 4 -> null
8	5	0	1	i < pos-1 and curr != nil? True	Move curr to next	1 -> 2 -> 3 -> 4 -> null
9	5	1	2	i < pos-1 and curr != nil? True	Move curr to next	1 -> 2 -> 3 -> 4 -> null
10	5	2	3	i < pos-1 and curr != nil? True	Move curr to next	1 -> 2 -> 3 -> 4 -> null
11	5	3	4	i < pos-1 and curr != nil? False	Stop loop	1 -> 2 -> 3 -> 4 -> null
12	5	-	4	curr == nil or curr.next == nil? True	Position out of range, no deletion	1 -> 2 -> 3 -> 4 -> null
13	5	-	-	-	Return head	1 -> 2 -> 3 -> 4 -> null

💡 Loop ends when i reaches pos-1 or curr is nil; deletion only if node at position exists.

Variable Tracker

Variable	Start	After 1	After 2	After 3	Final
pos	2	2	2	2	2
i	-	0	1	1	1
curr Node Value	1	1	2	2	2
List State	1 -> 2 -> 3 -> 4 -> null	1 -> 2 -> 3 -> 4 -> null	1 -> 2 -> 3 -> 4 -> null	1 -> 2 -> 4 -> null	1 -> 2 -> 4 -> null

Key Moments - 3 Insights

Why do we stop the loop at pos-1 and not pos?

Because we need to reach the node just before the one to delete to change its next pointer, as shown in execution_table row 3.

What happens if the position is greater than the list length?

The code checks if curr or curr.next is nil (row 12), and if so, it does not delete any node and returns the original list.

Why do we handle position 0 separately?

Because deleting the head means returning head.next as the new head, which is a special case handled in row 1.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of curr Node at step 4 when pos=2?

A 1

B 2

C 3

D 4

💡 Hint

Check the 'curr Node Value' column at step 4 in execution_table.

At which step does the deletion actually happen for pos=2?

A Step 5

B Step 3

C Step 4

D Step 6

💡 Hint

Look for the action 'curr.next = curr.next.next' in execution_table.

If pos is 0, what will be the new head node value after deletion?

A 1

B 3

C 2

D null

💡 Hint

Refer to execution_table step 1 where pos == 0 case is handled.

Concept Snapshot

Delete Node at Specific Position in Linked List:
- If pos == 0, return head.next (delete head).
- Else, move to node at pos-1.
- If next node exists, skip it by curr.next = curr.next.next.
- If position invalid, return original list.
- Returns updated head pointer.

Full Transcript

This visual trace 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 by returning head.next. Otherwise, we move a pointer to the node just before the target position. If the next node exists, we change the next pointer to skip the node at the position, effectively deleting it. If the position is out of range, no deletion happens. The execution table tracks each step, variable values, and list state changes. Key moments clarify why we stop at pos-1 and handle position zero separately. The quiz tests understanding of pointer positions and deletion steps.

Practice

1. What does deleting a node at a specific position in a linked list mean?

easy

A. Adding a new node at that position

B. Removing the node at that position and linking its previous node to the next node

C. Swapping the node at that position with the last node

D. Counting the number of nodes before that position

Solution

1. Step 1: Understand node deletion in linked list

   Deleting a node means removing it and connecting the previous node to the next node to keep the list intact.

2. Step 2: Identify what happens at the specific position

   The node at the given position is removed, and the previous node's next pointer is updated to skip the deleted node.

3. Final Answer:

   Removing the node at that position and linking its previous node to the next node -> Option B

4. Quick Check:

   Delete node = remove and link neighbors [OK]

Hint: Delete means remove node and link neighbors [OK]

Common Mistakes:

• Thinking deletion adds a node
• Swapping nodes instead of deleting
• Only counting nodes without deletion

2. Which of the following Go code snippets correctly deletes a node at position pos in a singly linked list starting with head?

easy

A. curr := head; for i := 0; i <= pos; i++ { curr = curr.next }; curr.next = curr.next.next

B. head = head.next; for i := 0; i < pos; i++ { head = head.next }

C. if pos == 0 { head = head.next } else { curr := head; for i := 0; i < pos-1; i++ { curr = curr.next }; curr.next = curr.next.next }

D. for i := 0; i < pos; i++ { head = head.next }; head = head.next.next

Solution

1. Step 1: Check deletion at position 0

   If position is 0, we update head to head.next to remove the first node.

2. Step 2: Traverse to node before position and update links

   For other positions, we move to node before the target and set its next to skip the deleted node.

3. Final Answer:

   if pos == 0 { head = head.next } else { curr := head; for i := 0; i < pos-1; i++ { curr = curr.next }; curr.next = curr.next.next } -> Option C

4. Quick Check:

   Correct traversal and link update = if pos == 0 { head = head.next } else { curr := head; for i := 0; i < pos-1; i++ { curr = curr.next }; curr.next = curr.next.next } [OK]

Hint: Update previous node's next to skip deleted node [OK]

Common Mistakes:

• Not handling position 0 separately
• Looping one extra time causing nil pointer
• Incorrectly updating head inside loop

3. What is the output linked list after deleting the node at position 2 from the list: 10 -> 20 -> 30 -> 40 -> 50 -> null?

type Node struct {
  data int
  next *Node
}

// Assume head points to 10
// Delete node at position 2
func deleteAtPosition(head *Node, pos int) *Node {
  if pos == 0 {
    return head.next
  }
  curr := head
  for i := 0; i < pos-1; i++ {
    curr = curr.next
  }
  curr.next = curr.next.next
  return head
}

medium

A. 10 -> 20 -> 40 -> 50 -> null

B. 10 -> 20 -> 30 -> 50 -> null

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

D. 10 -> 30 -> 40 -> 50 -> null

Solution

1. Step 1: Identify node at position 2

   Position 2 node is the third node with value 30.

2. Step 2: Update links to remove node 30

   Node at position 1 (20) next pointer is updated to node at position 3 (40), skipping 30.

3. Final Answer:

   10 -> 20 -> 40 -> 50 -> null -> Option A

4. Quick Check:

   Deleted 30 at pos 2 = 10->20->40->50 [OK]

Hint: Skip node at position by linking previous to next [OK]

Common Mistakes:

• Deleting wrong node index
• Not updating links correctly
• Returning wrong head pointer

4. The following Go code tries to delete a node at position pos but causes a runtime error. What is the error and how to fix it?

func deleteAtPosition(head *Node, pos int) *Node {
  curr := head
  for i := 0; i < pos; i++ {
    curr = curr.next
  }
  curr.next = curr.next.next
  return head
}

medium

A. Logic error because loop goes to pos instead of pos-1; fix loop to i < pos-1

B. Syntax error due to missing return statement; fix by adding return head

C. No error; code works fine

D. Runtime error due to nil pointer when pos is 0; fix by handling pos 0 separately

Solution

1. Step 1: Analyze loop traversal

   The loop moves curr to the node at position pos, but we need the node before pos to update links.

2. Step 2: Fix loop to stop at node before pos

   Change loop condition to i < pos-1 so curr points to previous node, allowing safe link update.

3. Final Answer:

   Logic error because loop goes to pos instead of pos-1; fix loop to i < pos-1 -> Option A

4. Quick Check:

   Loop to pos-1 for previous node [OK]

Hint: Loop to node before position, not at position [OK]

Common Mistakes:

• Looping to pos causing nil pointer
• Not handling pos 0 case
• Assuming curr.next always exists

5. Given a singly linked list with nodes: 5 -> 10 -> 15 -> 20 -> 25 -> null, write the resulting list after deleting nodes at positions 0, 2, and then 1 in that order. What is the final list?

hard

A. 10 -> 20 -> null

B. 10 -> 15 -> 25 -> null

C. 5 -> 15 -> 25 -> null

D. 10 -> 25 -> null

Solution

1. Step 1: Delete node at position 0

   Remove first node (5), list becomes 10 -> 15 -> 20 -> 25 -> null.

2. Step 2: Delete node at position 2

   Positions now: 0=10,1=15,2=20,3=25. Remove node 20, list becomes 10 -> 15 -> 25 -> null.

3. Step 3: Delete node at position 1

   Positions now: 0=10,1=15,2=25. Remove node 15, list becomes 10 -> 25 -> null.

4. Final Answer:

   10 -> 25 -> null -> Option D

5. Quick Check:

   Delete 0,2,1 in order = 10->25 [OK]

Hint: Update list after each deletion before next [OK]

Common Mistakes:

• Not updating positions after deletions
• Deleting wrong nodes due to stale positions
• Confusing zero-based indexing