Delete Node at Specific Position in DSA Python - 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 the node before the target, then skip the target node by changing pointers.

Execution Sample

DSA Python

class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

def delete_at_position(head, pos):
    if pos == 0:
        return head.next
    current = head
    for _ in range(pos - 1):
        if current.next is None:
            return head
        current = current.next
    if current.next is not None:
        current.next = current.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	current.data	Condition	Action	List State
1	3	1	pos == 0? False	Move to traverse loop	1 -> 2 -> 3 -> 4 -> 5 -> null
2	3	1	Traverse loop iteration 1	current moves to node with data 2	1 -> 2 -> 3 -> 4 -> 5 -> null
3	3	2	Traverse loop iteration 2	current moves to node with data 3	1 -> 2 -> 3 -> 4 -> 5 -> null
4	3	3	current.next is not None	Skip node at position 3 (node with data 4)	1 -> 2 -> 3 -> 5 -> null
5	3	3	Return head	Return updated list head	1 -> 2 -> 3 -> 5 -> null
6	End	-	-	Stop	Final list: 1 -> 2 -> 3 -> 5 -> null

💡 Traversal ends after skipping node at position 3, list updated and returned.

Variable Tracker

Variable	Start	After 1	After 2	After 3	Final
pos	3	3	3	3	3
current.data	1	2	3	3	3
head	1 -> 2 -> 3 -> 4 -> 5 -> null	1 -> 2 -> 3 -> 4 -> 5 -> null	1 -> 2 -> 3 -> 4 -> 5 -> null	1 -> 2 -> 3 -> 5 -> null	1 -> 2 -> 3 -> 5 -> null

Key Moments - 3 Insights

Why do we check if pos == 0 separately?

Because deleting the head node means changing the head pointer itself, not just skipping a node. This is shown in execution_table row 1 where pos == 0 is False, so we handle it differently.

What happens if the position is out of range?

If during traversal current.next becomes None before reaching the node before position, we stop and return the original list unchanged. This prevents errors and is shown in the traversal loop condition in execution_table row 3.

How does skipping the node work?

We change current.next to current.next.next, effectively removing the node at position from the chain. This is shown in execution_table row 4 where the node with data 4 is skipped.

Visual Quiz - 3 Questions

Look at the execution_table at step 4, which node is being skipped?

A Node with data 3

B Node with data 4

C Node with data 5

D Node with data 2

💡 Hint

Check the 'Action' and 'List State' columns at step 4 in execution_table.

At which step does the current pointer move to the node with data 3?

A Step 4

B Step 2

C Step 3

D Step 1

💡 Hint

Look at the 'current.data' column in execution_table rows.

If pos was 0, what would be the new head of the list?

A Node with data 2

B Node with data 3

C Node with data 1

D Node with data 4

💡 Hint

Refer to the code and key_moments about deleting the head node.

Concept Snapshot

Delete Node at Specific Position in Linked List:
- If position is 0, remove head by returning head.next.
- Else, traverse to node before position.
- Change its next pointer to skip the target node.
- Return updated head.
- Handles out-of-range positions safely.

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 one we want to delete. If we reach the end before that, we stop and return the original list unchanged. If the node exists, we skip it by changing the next pointer of the previous node to point to the node after the one being deleted. This effectively removes the target node from the list. The execution table traces each step, showing how the current pointer moves and how the list changes after deletion. Key moments clarify why we treat the head node differently and how skipping works. The visual quiz tests understanding of these steps.

Practice

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

easy

A. The last node is removed

B. The list remains unchanged

C. The head node is removed and the next node becomes the new head

D. All nodes are deleted

Solution

1. Step 1: Understand position 0 in linked list

   Position 0 refers to the head node of the list.

2. Step 2: Effect of deleting head node

   Deleting the head means the next node becomes the new head.

3. Final Answer:

   The head node is removed and the next node becomes the new head -> Option C

4. Quick Check:

   Deleting position 0 removes head [OK]

Hint: Deleting position 0 always removes the head node [OK]

Common Mistakes:

• Thinking last node is deleted at position 0
• Assuming list stays same after deletion
• Deleting all nodes instead of one

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

easy

A. head = head.next if pos == 1 else head

B. if pos == 0: head = head.next

C. head.next = head if pos == 0 else head.next

D. head = head.prev if pos == 0 else head.next

Solution

1. Step 1: Check deletion at position 0

   Deleting at position 0 means moving head to next node.

2. Step 2: Verify syntax correctness

   if pos == 0: head = head.next correctly assigns head to head.next when pos is 0.

3. Final Answer:

   if pos == 0: head = head.next -> Option B

4. Quick Check:

   Correct syntax for deleting head node [OK]

Hint: Deleting head means head = head.next [OK]

Common Mistakes:

• Using head.prev which doesn't exist in singly linked list
• Wrong condition for position check
• Assigning head incorrectly

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

class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

def delete_node(head, pos):
    if pos == 0:
        return head.next
    current = head
    for _ in range(pos - 1):
        current = current.next
    current.next = current.next.next
    return head

head = Node(10)
head.next = Node(20)
head.next.next = Node(30)
head.next.next.next = Node(40)
head = delete_node(head, 2)

# Print list
current = head
result = []
while current:
    result.append(current.data)
    current = current.next
print(result)

medium

A. [10, 20, 40]

B. [10, 30, 40]

C. [20, 30, 40]

D. [10, 20, 30, 40]

Solution

1. Step 1: Identify node at position 2

   Position 2 node has value 30 in the list 10 -> 20 -> 30 -> 40.

2. Step 2: Delete node at position 2

   Node 20's next pointer is updated to node 40, skipping node 30.

3. Final Answer:

   [10, 20, 40] -> Option A

4. Quick Check:

   Deleted node 30 at position 2 [OK]

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

Common Mistakes:

• Deleting wrong node due to off-by-one error
• Not updating next pointer correctly
• Returning wrong head

4. Find the error in the following code snippet that deletes a node at position pos in a singly linked list:

def delete_node(head, pos):
    if pos == 0:
        head = head.next
    current = head
    for _ in range(pos - 1):
        current = current.next
    current.next = current.next.next
    return head

medium

A. No error, code is correct

B. Loop runs one time too many

C. current.next.next may cause AttributeError if current.next is None

D. Missing return after deleting head node

Solution

1. Step 1: Check deletion at position 0

   When pos is 0, head is updated but not returned immediately.

2. Step 2: Effect of missing return

   Code continues and tries to access current.next causing errors or wrong behavior.

3. Final Answer:

   Missing return after deleting head node -> Option D

4. Quick Check:

   Return immediately after deleting head [OK]

Hint: Return immediately after deleting head node [OK]

Common Mistakes:

• Not returning head after deleting first node
• Ignoring edge cases when list is empty
• Assuming current.next always exists

5. Given a singly linked list 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, 25]

B. [10, 15, 25]

C. [10, 20]

D. [5, 15, 25]

Solution

1. Step 1: Delete node at position 0

   Deleting head (5), list becomes 10 -> 15 -> 20 -> 25.

2. Step 2: Delete node at position 2

   Node at position 2 is 20, deleting it results in 10 -> 15 -> 25.

3. Step 3: Delete node at position 1

   Node at position 1 is 15, deleting it results in 10 -> 25.

4. Final Answer:

   [10, 25] -> Option A

5. Quick Check:

   Sequential deletions update list correctly [OK]

Hint: Delete nodes stepwise, update positions after each deletion [OK]

Common Mistakes:

• Not updating list after each deletion
• Confusing positions after deletions
• Deleting wrong nodes due to static indexing