Delete Node at Specific Position in DSA C# - Execution Trace

Concept Flow - Delete Node at Specific Position

Start at head

↓

Check if position is 1

|Yes↓

Delete head node

↓

Else

↓

Traverse to node before position

↓

Check if next node exists

|Yes↓

Delete node at position

↓

Update links

↓

End

Start from the head, if position is 1 delete head. Otherwise, move to node before position, then remove the node at position by updating links.

Execution Sample

DSA C#

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

Node DeleteAtPosition(Node head, int pos) {
  if (head == null) return head;
  if (pos == 1) {
    return head.next;
  }
  Node current = head;
  int count = 1;
  while (current != null && count < pos - 1) {
    current = current.next;
    count++;
  }
  if (current == null || current.next == null) {
    return head;
  }
  current.next = current.next.next;
  return head;
}

Deletes the node at the given position in a singly linked list and returns the possibly updated head.

Execution Table

Step	Current Node Data	Position Counter	Condition Checked	Action Taken	List State After Action
1	10 (head)	1	pos == 1?	No, proceed to traversal	10 -> 20 -> 30 -> 40 -> null
2	10	1	position counter < pos - 1?	Yes, move to next	10 -> 20 -> 30 -> 40 -> null
3	20	2	position counter < pos - 1?	Yes, move next	10 -> 20 -> 30 -> 40 -> null
4	30	3	position counter < pos - 1?	No, stop traversal	10 -> 20 -> 30 -> 40 -> null
5	30	3	next node exists?	Yes, delete next node (40)	10 -> 20 -> 30 -> null
6	End	-	Traversal complete	Node deleted, links updated	10 -> 20 -> 30 -> null
7	-	-	pos out of range?	If yes, no deletion	List unchanged

💡 Traversal ends when node before position is reached and deletion is done or position is invalid.

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	After Step 5	Final
current	10 (head)	20	30	30	30	30
positionCounter	1	2	3	3	3	3
head	10 -> 20 -> 30 -> 40 -> null	10 -> 20 -> 30 -> 40 -> null	10 -> 20 -> 30 -> 40 -> null	10 -> 20 -> 30 -> 40 -> null	10 -> 20 -> 30 -> null	10 -> 20 -> 30 -> null

Key Moments - 3 Insights

Why do we check if position is 1 separately?

Because deleting the head node requires updating the head pointer itself, unlike other positions where we update the next pointer of the previous node. See execution_table step 1.

What happens if the position is greater than the list length?

The traversal stops when current node's next is null before reaching position - 1, so no deletion happens. See execution_table step 7.

Why do we stop traversal at position - 1, not at position?

We stop at the node before the one to delete to update its next pointer to skip the deleted node. See execution_table steps 3 and 4.

Visual Quiz - 3 Questions

Look at the execution_table, what is the list state after step 1?

A 10 -> 30 -> 40 -> null

B 10 -> 20 -> 30 -> 40 -> null

C 20 -> 30 -> 40 -> null

D 30 -> 40 -> null

💡 Hint

Check the 'List State After Action' column at step 1 in execution_table.

Look at the execution_table, at which step does the traversal stop before deleting the node at position 4?

A Step 2

B Step 3

C Step 4

D Step 5

💡 Hint

Look at 'Condition Checked' and 'Action Taken' columns around steps 3 and 4.

If the position to delete is 5 but the list has only 4 nodes, what happens?

A No deletion occurs

B Head node is deleted

C Node at position 4 is deleted

D Last node is deleted

💡 Hint

Refer to execution_table step 7 about position out of range.

Concept Snapshot

Delete Node at Specific Position in Linked List:
- If position == 1, update head to head.next
- Else, traverse to node before position
- Update its next to skip the node at position
- If position invalid, no change
- Maintains list integrity after deletion

Full Transcript

To delete a node at a specific position in a singly linked list, first check if the position is 1. If yes, delete the head by moving the head pointer to the next node. Otherwise, traverse the list to the node just before the position to delete. Then, update its next pointer to skip the node at the position, effectively deleting it. If the position is beyond the list length, no deletion occurs. This process ensures the list remains connected and valid after deletion.

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