Delete Node at Specific Position in DSA Python

Mental Model

To remove a node at a certain position, we find the node just before it and change its pointer to skip the node to delete.

Analogy: Imagine a chain of paper clips linked together. To remove one clip in the middle, you unhook the clip before it and link it directly to the clip after the one you want to remove.

Head -> 1 -> 2 -> 3 -> 4 -> 5 -> null
Positions: 1    2    3    4    5

Dry Run Walkthrough

Input: list: 1 -> 2 -> 3 -> 4 -> 5, delete node at position 3

Goal: Remove the node at position 3 and keep the list connected

Step 1: Check if position is 1 (head), it is not

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

Why: If position is 1, we remove the head differently

Step 2: Start at head (node 1), move to node before position 3 (node 2)

Head -> 1 -> [curr->2] -> 3 -> 4 -> 5 -> null

Why: We need the node before the one to delete to change its pointer

Step 3: Change node 2's next pointer to skip node 3 and point to node 4

Head -> 1 -> 2 -> 4 -> 5 -> null

Why: This removes node 3 from the chain

Result:

Head -> 1 -> 2 -> 4 -> 5 -> null

Annotated Code

DSA Python

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

class LinkedList:
    def __init__(self):
        self.head = None

    def append(self, data):
        new_node = Node(data)
        if not self.head:
            self.head = new_node
            return
        last = self.head
        while last.next:
            last = last.next
        last.next = new_node

    def delete_at_position(self, position):
        if not self.head:
            return  # empty list, nothing to delete
        if position == 1:
            self.head = self.head.next  # remove head
            return
        curr = self.head
        count = 1
        while curr and count < position - 1:
            curr = curr.next
            count += 1
        if not curr or not curr.next:
            return  # position out of range
        curr.next = curr.next.next  # skip the node at position

    def __str__(self):
        result = []
        curr = self.head
        while curr:
            result.append(str(curr.data))
            curr = curr.next
        return ' -> '.join(result) + ' -> null'

# Driver code
ll = LinkedList()
for i in [1, 2, 3, 4, 5]:
    ll.append(i)
print("Before deletion:", ll)
ll.delete_at_position(3)
print("After deletion at position 3:", ll)

if position == 1: self.head = self.head.next # remove head

handle deletion of the first node by moving head pointer

while curr and count < position - 1: curr = curr.next count += 1

advance to node before the one to delete

if not curr or not curr.next: return # position out of range

check if position is valid within list length

curr.next = curr.next.next # skip the node at position

unlink the node at position by skipping it

Output

Before deletion: 1 -> 2 -> 3 -> 4 -> 5 -> null

After deletion at position 3: 1 -> 2 -> 4 -> 5 -> null

Complexity Analysis

Time: O(n) because we may need to traverse up to n nodes to reach the position

Space: O(1) because we only use a few pointers and no extra data structures

vs Alternative: Compared to rebuilding the list without the node, this pointer change is more efficient and uses constant space

Edge Cases

empty list

nothing happens, no error

DSA Python

if not self.head:
    return  # empty list, nothing to delete

delete head node (position 1)

head moves to next node

DSA Python

if position == 1:
    self.head = self.head.next  # remove head

position out of range (greater than list length)

no deletion occurs

DSA Python

if not curr or not curr.next:
    return  # position out of range

When to Use This Pattern

When asked to remove a node at a specific position in a linked list, use the delete-at-position pattern by adjusting pointers to skip the target node.

Common Mistakes

Mistake: Trying to delete the node without updating the previous node's next pointer
Fix: Always find the node before the target and update its next pointer to skip the target node

Mistake: Not handling deletion of the head node separately
Fix: Check if position is 1 and update head pointer accordingly

Summary

Deletes a node at a given position by changing pointers to skip it.

Use when you need to remove a node from anywhere in a singly linked list.

The key is to find the node before the target and link it to the node after the target.

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