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.