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
Positions:   1    2    3    4

Dry Run Walkthrough

Input: list: 1 -> 2 -> 3 -> 4 -> null, 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 node), it is not

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

Why: We need to delete a node other than the head, so we prepare to find the previous node

Step 2: Traverse to node at position 2 (previous node to delete)

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

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

Step 3: Change pointer of node 2 to skip node 3 and point to node 4

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

Why: This removes node 3 from the chain by skipping it

Result:

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

Annotated Code

DSA C#

using System;

public class Node
{
    public int data;
    public Node next;

    public Node(int data)
    {
        this.data = data;
        this.next = null;
    }
}

public class LinkedList
{
    public Node head;

    public void DeleteAtPosition(int position)
    {
        if (head == null) return; // empty list

        if (position == 1)
        {
            head = head.next; // remove head
            return;
        }

        Node current = head;
        for (int i = 1; i < position - 1; i++)
        {
            if (current.next == null) return; // position out of bounds
            current = current.next; // move to previous node
        }

        if (current.next == null) return; // position out of bounds

        current.next = current.next.next; // skip the node at position
    }

    public void PrintList()
    {
        Node temp = head;
        while (temp != null)
        {
            Console.Write(temp.data);
            if (temp.next != null) Console.Write(" -> ");
            temp = temp.next;
        }
        Console.WriteLine(" -> null");
    }
}

public class Program
{
    public static void Main()
    {
        LinkedList list = new LinkedList();
        list.head = new Node(1);
        list.head.next = new Node(2);
        list.head.next.next = new Node(3);
        list.head.next.next.next = new Node(4);

        list.DeleteAtPosition(3);
        list.PrintList();
    }
}

if (position == 1) { head = head.next; // remove head return; }

Handle deletion of the first node by moving head pointer

for (int i = 1; i < position - 1; i++) { if (current.next == null) return; // position out of bounds current = current.next; // move to previous node }

Traverse to the node just before the one to delete

if (current.next == null) return; // position out of bounds

Check if position is valid (node to delete exists)

current.next = current.next.next; // skip the node at position

Remove the node by skipping it in the 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 arrays where deletion requires shifting elements (O(n)), linked list deletion is efficient as it only changes pointers

Edge Cases

empty list

No deletion occurs, function returns immediately

DSA C#

if (head == null) return; // empty list

delete head node (position 1)

Head pointer moves to next node, removing the first node

DSA C#

if (position == 1)
        {
            head = head.next; // remove head
            return;
        }

position out of bounds (greater than list length)

No deletion occurs, function returns safely

DSA C#

if (current.next == null) return; // position out of bounds

When to Use This Pattern

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

Common Mistakes

Mistake: Trying to delete the node without updating the previous node's next pointer
Fix: Always update the previous node's next pointer to skip the node to delete

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

Mistake: Not checking if position is out of bounds leading to null reference errors
Fix: Add checks to return early if position is invalid

Summary

Deletes a node at a specific position in a singly linked list by adjusting 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 link it to the node after the target.

Practice

1. What does deleting a node at a specific position in a singly 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. Reversing the entire list up to 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 the effect of deletion at a 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 previous to next [OK]

Hint: Delete means remove node and link previous to next [OK]

Common Mistakes:

• Thinking deletion adds a node
• Confusing deletion with swapping nodes
• Assuming deletion reverses the list

2. Which of the following is the correct C# syntax to delete a node at position pos in a singly linked list starting with head?

easy

A. head.next = null;

B. head = head.next[pos];

C. if (pos == 0) head = head.next;

D. head.deleteNode(pos);

Solution

1. Step 1: Check deletion at head position

   If position is 0, deleting means moving head to next node: head = head.next;.

2. Step 2: Validate other options

   head.next = null;: head.next = null; deletes second node regardless of pos. head = head.next[pos];: head = head.next[pos]; invalid syntax (no array indexing on nodes). head.deleteNode(pos);: head.deleteNode(pos); calls non-existent method.

3. Final Answer:

   if (pos == 0) head = head.next; -> Option C

4. Quick Check:

   Delete head = head.next [OK]

Hint: To delete head, assign head to head.next [OK]

Common Mistakes:

• Using array-like indexing on linked list
• Calling undefined methods
• Setting next to null incorrectly

3. What will be the linked list after deleting the node at position 2 from the list: 1 -> 3 -> 5 -> 7 -> null?

medium

A. 1 -> 3 -> 7 -> null

B. 1 -> 5 -> 7 -> null

C. 3 -> 5 -> 7 -> null

D. 1 -> 3 -> 5 -> null

Solution

1. Step 1: Identify node at position 2

   Positions start at 0: 0->1, 1->3, 2->5, 3->7. Node at position 2 is 5.

2. Step 2: Delete node 5 and link previous to next

   Remove 5, link node with value 3 to node with value 7.

3. Final Answer:

   1 -> 3 -> 7 -> null -> Option A

4. Quick Check:

   Delete node 5 at pos 2 = 1->3->7 [OK]

Hint: Count from zero, remove node at position, link neighbors [OK]

Common Mistakes:

• Deleting wrong node by counting from 1
• Not linking previous node to next
• Removing head instead of position 2

4. Given the following code snippet to delete a node at position pos, what is the error?

Node current = head;
for (int i = 0; i < pos - 1; i++) {
    current = current.next;
}
current.next = current.next.next;

medium

A. It does not handle deletion at position 0

B. It causes a syntax error due to missing semicolons

C. It deletes the node after the given position

D. It causes infinite loop

Solution

1. Step 1: Analyze loop for position 0

   For pos=0, loop condition i < pos - 1 (i < -1) is false, current remains head, then current.next = current.next.next; deletes SECOND node (pos 1) instead of head.

2. Step 2: Check deletion logic for other positions

   For pos >=1, loop moves current to node before target and skips target correctly.

3. Final Answer:

   It does not handle deletion at position 0 -> Option A

4. Quick Check:

   Code misses head deletion case [OK]

Hint: Check if code handles deleting head (pos 0) separately [OK]

Common Mistakes:

• Ignoring head deletion case
• Assuming loop runs for pos=0
• Confusing syntax errors with logic errors

5. You have a singly linked list: 10 -> 20 -> 30 -> 40 -> 50 -> null. You want to delete the node at position 4. After deletion, what will be the list? Also, what happens if you try to delete at position 5?

hard

A. 10 -> 20 -> 30 -> 40 -> 50 -> null; Deleting at position 5 deletes head

B. 10 -> 20 -> 30 -> 40 -> null; Deleting at position 5 causes no change (position out of range)

C. 10 -> 20 -> 30 -> 40 -> 50 -> null; Deleting at position 5 deletes last node

D. 10 -> 20 -> 30 -> 40 -> null; Deleting at position 5 causes runtime error (null reference)

Solution

1. Step 1: Delete node at position 4

   Positions: 0->10,1->20,2->30,3->40,4->50. Deleting node 50 removes last node, list becomes 10->20->30->40->null.

2. Step 2: Attempt deletion at position 5

   Position 5 does not exist. Trying to access node at pos 5 causes null reference error (runtime error).

3. Final Answer:

   10 -> 20 -> 30 -> 40 -> null; Deleting at position 5 causes runtime error (null reference) -> Option D

4. Quick Check:

   Delete last node works; out-of-range causes error [OK]

Hint: Deleting beyond list length causes runtime error [OK]

Common Mistakes:

• Assuming out-of-range deletion does nothing
• Deleting wrong node at position 5
• Confusing last node position with list length