Delete Node at Specific Position in DSA Typescript - Execution Trace

Concept Flow - Delete Node at Specific Position

Start at head

↓

Check if position is 0

|Yes↓

Delete head node

No↓

Traverse to node before position

↓

Check if next node exists

|No↓

Position invalid, stop

Yes↓

Delete node at position

Start from the head, if position is zero delete head. Otherwise, move to node before position, check if next node exists, then delete it by adjusting pointers.

Execution Sample

DSA Typescript

class Node {
  constructor(public data: number, public next: Node | null = null) {}
}

function deleteAtPosition(head: Node | null, pos: number): Node | null {
  if (!head) return null;
  if (pos === 0) return head.next;
  let current = head;
  for (let i = 0; i < pos - 1; i++) {
    if (!current.next) return head;
    current = current.next;
  }
  if (current.next) current.next = current.next.next;
  return head;
}

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

Execution Table

Step	Action	Position	Current Node Data	Condition	Pointer Update	List State
1	Check if head is null	2	1	head != null	No change	1 -> 2 -> 3 -> 4 -> 5 -> null
2	Check if position is 0	2	1	pos != 0	No change	1 -> 2 -> 3 -> 4 -> 5 -> null
3	Initialize current to head	2	1	N/A	No change	1 -> 2 -> 3 -> 4 -> 5 -> null
4	Loop i=0: move current to next	2	2	i < pos-1 (0 < 1)	current = 2	1 -> 2 -> 3 -> 4 -> 5 -> null
5	Loop i=1: move current to next	2	2	i < pos-1 (1 < 1) false	Loop ends	1 -> 2 -> 3 -> 4 -> 5 -> null
6	Check if current.next exists	2	2	current.next = 3 exists	Yes	1 -> 2 -> 3 -> 4 -> 5 -> null
7	Delete node at position by skipping	2	2	N/A	current.next = current.next.next (3 skipped)	1 -> 2 -> 4 -> 5 -> null
8	Return updated head	2	1	N/A	No change	1 -> 2 -> 4 -> 5 -> null
9	End	2	N/A	N/A	N/A	1 -> 2 -> 4 -> 5 -> null

💡 Position 2 node deleted by skipping it in the list

Variable Tracker

Variable	Start	After Step 4	After Step 5	After Step 7	Final
head	1	1	1	1	1
pos	2	2	2	2	2
current	1	2	2	2	2
current.next	2	3	3	4	4

Key Moments - 3 Insights

Why do we stop the loop at pos-1 and not pos?

Because we need to reach the node just before the one to delete to change its next pointer. See execution_table steps 4 and 5 where current moves to node at position 1 before deletion.

What happens if the position is 0?

The head node is deleted by returning head.next immediately, skipping the loop. This is shown in execution_table step 2.

Why do we check if current.next exists before deleting?

To avoid errors if position is beyond list length. If current.next is null, deletion is invalid and we return original list. See execution_table step 6.

Visual Quiz - 3 Questions

Look at the execution_table at step 4, what is the value of current node data?

A 1

B 2

C 3

D null

💡 Hint

Check the 'Current Node Data' column at step 4 in execution_table

At which step does the node actually get deleted from the list?

A Step 6

B Step 7

C Step 5

D Step 2

💡 Hint

Look for 'Pointer Update' that skips a node in execution_table

If position was 0, what would be the new head after deletion?

A Node with data 2

B Node with data 1

C Node with data 3

D null

💡 Hint

See execution_table step 2 where position 0 deletes head and returns head.next

Concept Snapshot

Delete Node at Specific Position in Linked List:
- If position is 0, return head.next to delete head
- Else, traverse to node before position
- Check if next node exists
- Change current.next to skip node at position
- Return updated head
- Handles invalid positions by no change

Full Transcript

This visual trace shows how to delete a node at a specific position in a singly linked list. We start by checking if the list is empty or if the position is zero. If zero, we delete the head by returning the next node. Otherwise, we move to the node just before the position to delete. We verify the next node exists to avoid errors. Then we delete the node by skipping it in the pointer chain. The execution table tracks each step, variable values, and list state. Key moments clarify why we stop traversal at position minus one and why we check for next node existence. The quiz tests understanding of current node data during traversal, the exact deletion step, and the effect of deleting the head node. This method safely updates the linked list and returns the new head.

Practice

1. What does deleting a node at a specific position in a singly linked list mean?

easy

A. Removing the node located at that position and linking its previous node to the next node

B. Adding a new node at that position

C. Swapping the node at that position with the last node

D. Counting the total nodes in the list

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: Apply to specific position

   At a specific position, we find the node before it and change its next pointer to skip the node to delete.

3. Final Answer:

   Removing the node located at that position and linking its previous node to the next node -> Option A

4. Quick Check:

   Delete node = remove and link neighbors [OK]

Hint: Delete means remove and link neighbors, not add or swap [OK]

Common Mistakes:

• Thinking deletion adds a node
• Confusing deletion with swapping nodes
• Ignoring the need to link previous and next nodes

2. Which of the following TypeScript code snippets correctly deletes a node at position pos in a singly linked list starting with head?

easy

A. if (pos === 0) head = head.next; else { let temp = head; for (let i = 0; i < pos - 1; i++) temp = temp.next; temp.next = temp.next.next; }

B. if (pos === 0) head = head.next; else { let temp = head; for (let i = 0; i < pos; i++) temp = temp.next; temp.next = temp.next.next; }

C. if (pos === 0) head = head.next; else { let temp = head; for (let i = 0; i <= pos; i++) temp = temp.next; temp.next = temp.next.next; }

D. if (pos === 0) head = head.next; else { let temp = head; for (let i = 1; i <= pos; i++) temp = temp.next; temp.next = temp.next.next; }

Solution

1. Step 1: Handle deletion at head (position 0)

   If position is 0, simply move head to next node to delete the first node.

2. Step 2: Traverse to node before position

   Loop from 0 to pos-1 to reach node before the one to delete, then link its next to next.next.

3. Final Answer:

   if (pos === 0) head = head.next; else { let temp = head; for (let i = 0; i < pos - 1; i++) temp = temp.next; temp.next = temp.next.next; } -> Option A

4. Quick Check:

   Loop to pos-1, then skip node [OK]

Hint: Loop to pos-1 to delete node at pos [OK]

Common Mistakes:

• Looping to pos instead of pos-1
• Not handling deletion at head correctly
• Accessing temp.next.next when temp.next is null

3. Given the linked list: 10 -> 20 -> 30 -> 40 -> 50 -> null and the code below, what will be the list after deleting the node at position 2?

let head = { val: 10, next: { val: 20, next: { val: 30, next: { val: 40, next: { val: 50, next: null } } } } };
let pos = 2;
if (pos === 0) head = head.next;
else {
  let temp = head;
  for (let i = 0; i < pos - 1; i++) temp = temp.next;
  temp.next = temp.next.next;
}

medium

A. 10 -> 30 -> 40 -> 50 -> null

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

C. 10 -> 20 -> 40 -> 50 -> null

D. 20 -> 30 -> 40 -> 50 -> null

Solution

1. Step 1: Identify node at position 2

   Position 2 node has value 30 (0-based indexing: 10 at 0, 20 at 1, 30 at 2).

2. Step 2: Delete node at position 2

   Traverse to node at position 1 (value 20), then set its next to node at position 3 (value 40), skipping 30.

3. Final Answer:

   10 -> 20 -> 40 -> 50 -> null -> Option C

4. Quick Check:

   Node 30 removed, neighbors linked [OK]

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

Common Mistakes:

• Deleting wrong node due to off-by-one error
• Not updating links properly
• Confusing position indexing

4. The following TypeScript code attempts to delete a node at position pos in a singly linked list but causes a runtime error. What is the error?

function deleteNode(head: Node | null, pos: number): Node | null {
  if (pos === 0) return head.next;
  let temp = head;
  for (let i = 0; i < pos; i++) {
    temp = temp.next!;
  }
  temp.next = temp.next!.next;
  return head;
}

medium

A. Incorrect loop range causes skipping the wrong node

B. Accessing temp.next when temp is null causes runtime error

C. Missing check for empty list before deletion

D. Returning head.next instead of head after deletion

Solution

1. Step 1: Analyze loop traversal

   The loop runs from 0 to pos, moving temp forward pos times, which can make temp null if pos >= list length.

2. Step 2: Identify null access

   After loop, temp may be null, so accessing temp.next causes runtime error.

3. Final Answer:

   Accessing temp.next when temp is null causes runtime error -> Option B

4. Quick Check:

   Loop overshoots, temp becomes null, then temp.next fails [OK]

Hint: Loop to pos-1, not pos, to avoid null access [OK]

Common Mistakes:

• Looping too far causing null pointer
• Not checking for empty list
• Misunderstanding return value after deletion

5. You have a singly linked list representing a playlist: Song1 -> Song2 -> Song3 -> Song4 -> Song5 -> null. You want to delete the 4th song (position 3). After deletion, you want to insert a new song Song6 at the same position. Which sequence of operations correctly achieves this?

hard

A. Delete node at position 3, then insert new node at head

B. Delete node at position 3, then traverse to position 3 and insert new node after it

C. Delete node at position 2, then traverse to position 3 and insert new node after it

D. Delete node at position 3, then traverse to position 2 and insert new node after it

Solution

1. Step 1: Delete node at position 3

   Remove the node at position 3 (Song4) by linking node at position 2 to node at position 4.

2. Step 2: Insert new node at position 3

   Traverse to position 2, then insert new node after it to place Song6 at position 3.

3. Final Answer:

   Delete node at position 3, then traverse to position 2 and insert new node after it -> Option D

4. Quick Check:

   Delete at pos 3, insert after pos 2 = new pos 3 [OK]

Hint: Insert after pos-1 to place new node at pos [OK]

Common Mistakes:

• Inserting at wrong position after deletion
• Deleting wrong node position
• Inserting at head instead of correct position