Delete Node at Specific Position in DSA Java - Execution Trace

Concept Flow - Delete Node at Specific Position

Start

↓

Check if head is null

|No↓

If position == 0

|Yes↓

Delete head node

↓

Else

↓

Traverse to node before position

↓

If next node exists

|Yes↓

Change next pointer to skip node

↓

Node deleted

↓

End

The flow checks if the list is empty or if the node to delete is the head, then deletes accordingly. Otherwise, it traverses to the node before the target and adjusts pointers to remove the node.

Execution Sample

DSA Java

class Node {
  int data;
  Node next;
}

Node deleteAtPosition(Node head, int pos) {
  if (head == null) return head;
  if (pos == 0) {
    return head.next;
  }
  Node current = head;
  for (int i = 0; current != null && i < pos - 1; i++) {
    current = current.next;
  }
  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	Position	Condition	Action	List State
1	head (data=1)	pos=3	head != null	Continue	1 -> 2 -> 3 -> 4 -> null
2	pos == 0?	3	False	Traverse to node before pos	1 -> 2 -> 3 -> 4 -> null
3	current = head (data=1)	pos=3	Traverse 1 step	current = current.next (data=2)	1 -> 2 -> 3 -> 4 -> null
4	current = 2	pos=3	Traverse 2nd step	current = current.next (data=3)	1 -> 2 -> 3 -> 4 -> null
5	current = 3	pos=3	Reached node before pos	Delete node at pos	1 -> 2 -> 3 -> null
6	current = 3	pos=3	current.next != null	current.next = current.next.next	1 -> 2 -> 3 -> null
7	-	-	-	Deletion complete	1 -> 2 -> 3 -> null
8	-	-	-	End	1 -> 2 -> 3 -> null

💡 Position reached and node deleted or position invalid, operation ends.

Variable Tracker

Variable	Start	After Step 3	After Step 4	After Step 6	Final
head	Node(1)	Node(1)	Node(1)	Node(1)	Node(1)
current	Node(1)	Node(2)	Node(3)	Node(3)	Node(3)
pos	3	3	3	3	3

Key Moments - 3 Insights

Why do we check if position is zero separately?

Because deleting the head node requires updating the head pointer itself, not just the next pointer of a previous node. See execution_table row 2 where pos==0 is checked.

What happens if the position is beyond the list length?

The traversal will reach null before the position, so no deletion occurs. The code stops safely without changes. This is implied after step 6 if current.next is null.

Why do we stop traversal at the node before the target position?

Because to delete a node, we need to change the previous node's next pointer to skip the target node. See execution_table rows 4 and 5.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of 'current' after step 4?

A Node with data=3

B Node with data=2

C Node with data=1

D null

💡 Hint

Check the 'current' column in execution_table row 4.

At which step does the linked list change from 1 -> 2 -> 3 -> 4 to 1 -> 2 -> 3 -> null?

A Step 7

B Step 3

C Step 5

D Step 2

💡 Hint

Look at the 'List State' column in execution_table rows 4, 5, and 7.

If position was 0, what would happen differently in the execution flow?

A Traversal would happen as usual.

B The head node would be deleted immediately.

C No deletion would occur.

D The last node would be deleted.

💡 Hint

Refer to execution_table row 2 where pos == 0 is checked.

Concept Snapshot

Delete Node at Specific Position in Linked List:
- If position is 0, delete head by moving head pointer.
- Else, traverse to node before position.
- Change next pointer to skip target node.
- Handle invalid positions safely.
- Result: node removed, list links updated.

Full Transcript

This visual execution trace shows how to delete a node at a specific position in a singly linked list. First, it checks if the list is empty or if the position is zero to delete the head node. Otherwise, it traverses to the node before the target position and updates the next pointer to skip the node to be deleted. The execution table tracks each step, current node, position, condition checks, actions, and the list state after each operation. Variable tracker shows how 'current' moves through the list. Key moments clarify why the head deletion is special, how out-of-range positions are handled, and why traversal stops before the target node. The quiz tests understanding of variable states and list changes during deletion. The snapshot summarizes the deletion steps simply.

Practice

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

easy

A. The list remains unchanged

B. The last node is removed

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 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 C

4. Quick Check:

   Deleting position 1 removes head [OK]

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

Common Mistakes:

• Thinking position 1 means last node
• Assuming list stays same after deletion
• Deleting all nodes instead of one

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

easy

A. if (pos == 1) head = head.next;

B. head = head.next.next;

C. head.next = null;

D. head = null;

Solution

1. Step 1: Check deletion at position 1

   If position is 1, we remove the head by pointing head to head.next.

2. Step 2: Validate syntax correctness

   if (pos == 1) head = head.next; correctly assigns head = head.next; others either skip nodes or nullify incorrectly.

3. Final Answer:

   if (pos == 1) head = head.next; -> Option A

4. Quick Check:

   Correct syntax for deleting head node [OK]

Hint: Deleting head means head = head.next [OK]

Common Mistakes:

• Skipping two nodes instead of one
• Setting head.next to null incorrectly
• Setting entire head to null without condition

3. Given the linked list: 10 -> 20 -> 30 -> 40 -> null, what is the list after deleting the node at position 3?

medium

A. 10 -> 20 -> 40 -> null

B. 10 -> 30 -> 40 -> null

C. 20 -> 30 -> 40 -> null

D. 10 -> 20 -> 30 -> null

Solution

1. Step 1: Identify node at position 3

   Position 3 node is 30 in the list 10 -> 20 -> 30 -> 40 -> null.

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

   Link node 20's next to node 40, skipping 30.

3. Final Answer:

   10 -> 20 -> 40 -> null -> Option A

4. Quick Check:

   Deleted 3rd node 30 correctly [OK]

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

Common Mistakes:

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

4. Consider this code snippet to delete a node at position pos in a singly linked list:

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

What error can occur if pos is 1?

medium

A. ArrayIndexOutOfBoundsException

B. NullPointerException because temp.next is null

C. The head node is deleted correctly

D. No error, deletion works fine

Solution

1. Step 1: Analyze loop for pos = 1

   Loop runs from i=1 to pos-2 = -1, so it does not run; temp = head.

2. Step 2: Access temp.next when pos=1

   temp.next is head.next, but deletion logic expects previous node; deleting head this way causes NullPointerException.

3. Final Answer:

   NullPointerException because temp.next is null -> Option B

4. Quick Check:

   Deleting position 1 needs special handling [OK]

Hint: Deleting head needs separate code; loop fails for pos=1 [OK]

Common Mistakes:

• Assuming loop runs for pos=1
• Not handling head deletion separately
• Expecting no error for pos=1

5. You have a singly linked list: 5 -> 10 -> 15 -> 20 -> 25 -> null. Write the resulting list after deleting the node at position 5, then position 1, and finally position 2 in that order.

hard

A. 10 -> 20 -> 25 -> null

B. 10 -> 15 -> 25 -> null

C. 5 -> 15 -> 20 -> 25 -> null

D. 10 -> 20 -> null

Solution

1. Step 1: Delete node at position 5

   Position 5 node is 25; after deletion list: 5 -> 10 -> 15 -> 20 -> null.

2. Step 2: Delete node at position 1

   Delete head (5); new list: 10 -> 15 -> 20 -> null.

3. Step 3: Delete node at position 2

   Position 2 node is 15; after deletion list: 10 -> 20 -> null.

4. Final Answer:

   10 -> 20 -> null -> Option D

5. Quick Check:

   Sequential deletions update list correctly [OK]

Hint: Delete from end, then head, then middle stepwise [OK]

Common Mistakes:

• Deleting wrong nodes after list changes
• Not updating head after first deletion
• Confusing positions after deletions