Delete Node at Specific Position in DSA Javascript

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

Dry Run Walkthrough

Input: list: 1 -> 2 -> 3 -> 4 -> null, delete node at position 2 (0-based index)

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

Step 1: Check if position is 0, if yes, remove head

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

Why: We handle removing the first node differently because head changes

Step 2: Start from head, move to node at position 1 (node with value 2)

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

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

Step 3: Change curr.next to skip node at position 2 (node with value 3) and point to node at position 3

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

Why: By skipping the node at position 2, we remove it from the list

Result:

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

Annotated Code

DSA Javascript

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

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

  append(value) {
    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) {
    if (!this.head) return; // empty list

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

    let curr = this.head;
    let count = 0;
    while (curr && count < position - 1) {
      curr = curr.next; // advance to node before target
      count++;
    }

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

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

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

// 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; // remove head return; }

handle removing the first node by updating head pointer

while (curr && count < position - 1) { curr = curr.next; // advance to node before target count++; }

move to node just before the one to delete

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

check if position is valid to avoid errors

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

remove target node by skipping it in the chain

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 rebuilding the list or shifting elements in an array (O(n)), this pointer change is efficient and direct

Edge Cases

empty list

no deletion happens, list remains empty

DSA Javascript

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

delete head node (position 0)

head pointer moves to next node, first node removed

DSA Javascript

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

position out of bounds (greater than list length)

no deletion happens, list unchanged

DSA Javascript

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

When to Use This Pattern

When you need to remove a node at a specific position in a linked list, use pointer updates to skip the node instead of rebuilding the list.

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 zero and update head pointer accordingly

Mistake: Not checking if position is out of bounds causing runtime errors
Fix: Add checks to ensure current and next nodes exist before deletion

Summary

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

Use when you want to remove a node from anywhere in the list efficiently.

The key is to reach the node before the target and change its next pointer to skip the target node.

Practice

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

easy

A. The head pointer moves to the next node, effectively removing the first node.

B. The last node is removed from the list.

C. The list becomes empty regardless of its size.

D. The node at position 1 is deleted instead.

Solution

1. Step 1: Understand position 0 in linked list

   Position 0 refers to the first node, also called the head.

2. Step 2: Effect of deleting head node

   Deleting the head means moving the head pointer to the next node, removing the first node from the list.

3. Final Answer:

   The head pointer moves to the next node, effectively removing the first node. -> Option A

4. Quick Check:

   Deleting position 0 removes the first node [OK]

Hint: Deleting position 0 means changing the head pointer [OK]

Common Mistakes:

• Thinking the last node is deleted instead
• Assuming the list becomes empty always
• Deleting the wrong node position

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

easy

A. head = head[pos + 1];

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

C. delete head[pos];

D. head.next = null;

Solution

1. Step 1: Check deletion at position 0

   Deleting at position 0 means moving head to head.next.

2. Step 2: Validate syntax correctness

   if (pos === 0) head = head.next; correctly assigns head to head.next. Other options misuse syntax or do not delete the node properly.

3. Final Answer:

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

4. Quick Check:

   Correct syntax for deleting head node is head = head.next [OK]

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

Common Mistakes:

• Using delete keyword incorrectly on linked list nodes
• Assigning head.next to null without updating head
• Accessing nodes with array-like syntax

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

medium

A. 10 -> 20 -> 30 -> null

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

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

D. 10 -> 20 -> 40 -> null

Solution

1. Step 1: Identify node at position 2

   Positions start at 0, so position 2 is the third node with value 30.

2. Step 2: Delete node at position 2

   Remove node 30 by linking node 20's next to node 40.

3. Final Answer:

   10 -> 20 -> 40 -> null -> Option D

4. Quick Check:

   Deleted node 30 at position 2 [OK]

Hint: Count from 0, remove node at that index [OK]

Common Mistakes:

• Deleting wrong node by miscounting positions
• Not updating the previous node's next pointer
• Confusing node values with positions

4. What is the error in the following code snippet for deleting a node at position pos in a singly linked list?

function deleteNode(head, pos) {
  let current = head;
  for (let i = 0; i < pos - 1; i++) {
    current = current.next;
  }
  current.next = current.next.next;
  return head;
}

medium

A. It does not handle deletion when pos is 0 (head node).

B. It incorrectly updates the head pointer.

C. It causes a syntax error due to missing semicolons.

D. It deletes the last node instead of the specified position.

Solution

1. Step 1: Analyze loop for position traversal

   The loop stops at node before position to delete, which is correct for pos > 0.

2. Step 2: Check handling of pos = 0

   When pos is 0, the loop does not run and current is head, but code does not update head pointer, so deletion fails.

3. Final Answer:

   It does not handle deletion when pos is 0 (head node). -> Option A

4. Quick Check:

   Missing head deletion case causes error [OK]

Hint: Always check if deleting head node separately [OK]

Common Mistakes:

• Ignoring edge case when pos is 0
• Assuming loop handles all positions
• Not updating head pointer when needed

5. You have a singly linked list: 5 -> 15 -> 25 -> 35 -> 45 -> null. You want to delete the node at position 4. What will the list look like after deletion? Also, what happens if you try to delete at position 5?

hard

A. After deletion at position 4: 5 -> 15 -> 25 -> 35 -> null; Deleting position 5 causes a runtime error.

B. After deletion at position 4: 5 -> 15 -> 25 -> 35 -> 45 -> null; Deleting position 5 removes the last node.

C. After deletion at position 4: 5 -> 15 -> 25 -> 35 -> null; Deleting position 5 does nothing as it's out of range.

D. After deletion at position 4: 15 -> 25 -> 35 -> 45 -> null; Deleting position 5 removes the head.

Solution

1. Step 1: Identify node at position 4

   Positions start at 0, so position 4 is the fifth node with value 45.

2. Step 2: Delete node at position 4

   Remove node 45 by linking node 35's next to null.

3. Step 3: Consider deletion at position 5

   Position 5 is out of list range (list length is 5), so deletion does nothing safely.

4. Final Answer:

   After deletion at position 4: 5 -> 15 -> 25 -> 35 -> null; Deleting position 5 does nothing as it's out of range. -> Option C

5. Quick Check:

   Deleting last node removes it; out-of-range deletion ignored [OK]

Hint: Deleting out-of-range position does nothing [OK]

Common Mistakes:

• Trying to delete non-existent node causing errors
• Confusing positions and node values
• Not updating previous node's next pointer correctly