Delete Node at Specific Position in DSA C++

Mental Model

We remove a node from a linked list by changing the pointer of the previous node 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 -> null

Dry Run Walkthrough

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

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

Step 1: Check if position is 1 to delete head

head -> 1 -> 2 -> 3 -> 4 -> null

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

Step 2: Traverse to node before position 3 (node with value 2)

head -> 1 -> [curr->2] -> 3 -> 4 -> null

Why: We need the previous node to change its pointer

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

head -> 1 -> 2 -> 4 -> null

Why: This removes node 3 from the chain

Result:

head -> 1 -> 2 -> 4 -> null

Annotated Code

DSA C++

#include <iostream>
using namespace std;

class Node {
public:
    int data;
    Node* next;
    Node(int val) : data(val), next(nullptr) {}
};

class LinkedList {
public:
    Node* head;
    LinkedList() : head(nullptr) {}

    void append(int val) {
        if (!head) {
            head = new Node(val);
            return;
        }
        Node* curr = head;
        while (curr->next) {
            curr = curr->next;
        }
        curr->next = new Node(val);
    }

    void deleteAtPosition(int pos) {
        if (!head) return; // empty list
        if (pos == 1) {
            Node* temp = head;
            head = head->next; // remove head
            delete temp;
            return;
        }
        Node* curr = head;
        for (int i = 1; i < pos - 1 && curr->next; i++) {
            curr = curr->next; // move to node before target
        }
        if (!curr->next) return; // position out of bounds
        Node* temp = curr->next;
        curr->next = temp->next; // skip target node
        delete temp;
    }

    void printList() {
        if (!head) {
            cout << "null" << endl;
            return;
        }
        Node* curr = head;
        while (curr) {
            cout << curr->data;
            if (curr->next) cout << " -> ";
            curr = curr->next;
        }
        cout << " -> null" << endl;
    }
};

int main() {
    LinkedList list;
    list.append(1);
    list.append(2);
    list.append(3);
    list.append(4);
    list.deleteAtPosition(3);
    list.printList();
    return 0;
}

if (pos == 1) {

Check if we need to delete the head node

head = head->next; // remove head

Update head pointer to next node to remove first node

for (int i = 1; i < pos - 1 && curr->next; i++) {

Traverse to node before the one to delete

curr->next = temp->next; // skip target node

Change pointer to remove target node from chain

Output

1 -> 2 -> 4 -> 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 or shifting elements in an array (O(n)), this pointer change is efficient and direct

Edge Cases

empty list

No deletion happens, function returns immediately

DSA C++

if (!head) return; // empty list

delete head node (position 1)

Head pointer moves to next node, old head deleted

DSA C++

if (pos == 1) {

position out of bounds (greater than list length)

No deletion happens, function returns safely

DSA C++

if (!curr->next) return; // position out of bounds

When to Use This Pattern

When you need to remove an element from a linked list at a given position, use pointer updates to skip the node instead of shifting elements.

Common Mistakes

Mistake: Not handling deletion of the head node separately
Fix: Add a condition to check if position is 1 and update head pointer accordingly

Mistake: Not checking if position is out of bounds causing null pointer errors
Fix: Check if curr->next is null before deleting to avoid invalid access

Summary

Deletes a node at a specific position in a singly linked list by updating pointers.

Use when you want to remove an element from anywhere in a linked list efficiently.

The key is to find the node before the target and change its next pointer to skip the target node.

Practice

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

easy

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

B. The last node is removed

C. The list remains unchanged

D. All nodes are deleted

Solution

1. Step 1: Understand position 1 in linked list

   Position 1 refers to the head node of the list.

2. Step 2: Delete the head node

   Removing 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 A

4. Quick Check:

   Deleting position 1 removes the head [OK]

Hint: Deleting position 1 means removing the head node [OK]

Common Mistakes:

• Thinking position 1 deletes the last node
• 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 C++?

easy

A. head = head->prev;

B. if (pos == 1) { head = head->next; }

C. delete head->next->prev;

D. head->next = NULL;

Solution

1. Step 1: Check deletion at position 1

   If position is 1, we update head to head->next to remove the first node.

2. Step 2: Verify syntax correctness

   if (pos == 1) { head = head->next; } correctly updates head pointer; others are invalid or incorrect for singly linked list.

3. Final Answer:

   if (pos == 1) { head = head->next; } -> Option B

4. Quick Check:

   Update head for position 1 deletion [OK]

Hint: For position 1, assign head = head->next [OK]

Common Mistakes:

• Using prev pointer in singly linked list
• Setting next pointer to NULL incorrectly
• Deleting wrong node pointer

3. What is the output linked list after deleting the node at position 3 from the list: 1 -> 2 -> 3 -> 4 -> 5 -> NULL?

medium

A. 2 -> 3 -> 4 -> 5 -> NULL

B. 1 -> 2 -> 3 -> 5 -> NULL

C. 1 -> 3 -> 4 -> 5 -> NULL

D. 1 -> 2 -> 4 -> 5 -> NULL

Solution

1. Step 1: Identify node at position 3

   Node at position 3 is the node with value 3.

2. Step 2: Remove node 3 and link previous to next

   Link node 2's next to node 4, skipping node 3.

3. Final Answer:

   1 -> 2 -> 4 -> 5 -> NULL -> Option D

4. Quick Check:

   Node 3 removed, list links 2 to 4 [OK]

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

Common Mistakes:

• Removing wrong node
• Not updating previous node's next pointer
• Deleting head instead of position 3

4. Given the code snippet below, what is the error when deleting a node at position 4?

void deleteNode(Node*& head, int pos) {
  Node* temp = head;
  for (int i = 1; i < pos - 1; i++) {
    temp = temp->next;
  }
  Node* toDelete = temp->next;
  temp->next = toDelete->next;
  delete toDelete;
}

medium

A. No check if position is valid or if temp is NULL

B. Incorrect loop range causing off-by-one error

C. Deleting head node incorrectly

D. Using delete on a pointer not allocated with new

Solution

1. Step 1: Analyze loop and pointer usage

   The loop moves temp to node before position to delete, but no checks if temp or temp->next is NULL.

2. Step 2: Identify missing validation

   Without checking if position is valid or temp is NULL, code may crash on invalid positions.

3. Final Answer:

   No check if position is valid or if temp is NULL -> Option A

4. Quick Check:

   Missing boundary checks cause runtime errors [OK]

Hint: Always check pointers before accessing next [OK]

Common Mistakes:

• Ignoring invalid position inputs
• Assuming list length is sufficient
• Not checking for NULL pointers

5. You have a singly linked list: 10 -> 20 -> 30 -> 40 -> 50 -> NULL. Write the resulting list after deleting the node at position 5 and then deleting the node at position 1.

hard

A. 20 -> 30 -> 40 -> 50 -> NULL

B. 10 -> 20 -> 30 -> 40 -> NULL

C. 20 -> 30 -> 40 -> NULL

D. 10 -> 20 -> 30 -> NULL

Solution

1. Step 1: Delete node at position 5

   Node at position 5 is 50, removing it results in list: 10 -> 20 -> 30 -> 40 -> NULL.

2. Step 2: Delete node at position 1

   Deleting head node 10 updates head to 20, final list: 20 -> 30 -> 40 -> NULL.

3. Final Answer:

   20 -> 30 -> 40 -> NULL -> Option C

4. Quick Check:

   Delete last then head node sequentially [OK]

Hint: Delete last node first, then head node for correct order [OK]

Common Mistakes:

• Deleting head first then last causing wrong list
• Not updating head after deleting position 1
• Forgetting to remove last node