Delete Node at Specific Position in DSA Typescript

Mental Model

We remove a node from a linked list by changing the pointer of the node before it 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 2 (0-based)

Goal: Remove the node at position 2 so the list becomes 1 -> 2 -> 4 -> null

Step 1: Check if position is 0 to delete head; it is not, so move to next step

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

Why: We only delete head differently; here position is 2

Step 2: Start from head (node 1), move to node before target position (node 2 at position 1)

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

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

Step 3: Change curr.next from node 3 to node 4, skipping node 3

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

Why: By skipping node 3, it is removed from the list

Result:

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

Annotated Code

DSA Typescript

class Node {
  value: number;
  next: Node | null;
  constructor(value: number) {
    this.value = value;
    this.next = null;
  }
}

class LinkedList {
  head: Node | null;
  constructor() {
    this.head = null;
  }

  append(value: number): void {
    const newNode = new Node(value);
    if (!this.head) {
      this.head = newNode;
      return;
    }
    let curr = this.head;
    while (curr.next) {
      curr = curr.next;
    }
    curr.next = newNode;
  }

  deleteAtPosition(position: number): void {
    if (!this.head) return; // empty list

    if (position === 0) {
      this.head = this.head.next; // delete head
      return;
    }

    let curr = this.head;
    let count = 0;
    while (curr && count < position - 1) {
      curr = curr.next!;
      count++;
    }

    if (!curr || !curr.next) return; // position out of bounds

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

  toString(): string {
    let curr = this.head;
    let result = '';
    while (curr) {
      result += curr.value + ' -> ';
      curr = curr.next;
    }
    return result + 'null';
  }
}

// Driver code
const list = new LinkedList();
list.append(1);
list.append(2);
list.append(3);
list.append(4);
console.log('Before deletion:', list.toString());
list.deleteAtPosition(2);
console.log('After deletion:', list.toString());

if (position === 0) { this.head = this.head.next; // delete head return; }

delete head node by moving head pointer to next node

while (curr && count < position - 1) { curr = curr.next!; count++; }

advance curr to node before target position

if (!curr || !curr.next) return; // position out of bounds

check if position is valid to avoid errors

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

remove target node by linking previous node to next of target

Output

Before deletion: 1 -> 2 -> 3 -> 4 -> null

After deletion: 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 array deletion which requires shifting elements O(n), linked list deletion is O(n) traversal but O(1) removal without shifting

Edge Cases

empty list

function returns immediately without error

DSA Typescript

if (!this.head) return; // empty list

delete head node (position 0)

head pointer moves to next node, removing first node

DSA Typescript

if (position === 0) {
  this.head = this.head.next; // delete head
  return;
}

position out of bounds (greater than list length)

function returns without changing list

DSA Typescript

if (!curr || !curr.next) return; // position out of bounds

When to Use This Pattern

When asked to remove a node at a specific position in a linked list, use pointer traversal to reach the node before it and adjust pointers to exclude the target node.

Common Mistakes

Mistake: Trying to delete a node without checking if position is valid or if list is empty
Fix: Add checks for empty list and position bounds before deletion

Mistake: Not handling deletion of head node separately
Fix: Handle position 0 by moving head pointer to next node

Mistake: Advancing pointer one step too far or not far enough before deletion
Fix: Stop at node before target position to change its next pointer correctly

Summary

Deletes a node at a given position in a singly linked list by adjusting pointers.

Use when you need to remove an element from anywhere in a linked list by position.

The key is to reach 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. 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