Insert at Specific Position in Doubly Linked List in DSA Javascript

Mental Model

We add a new item exactly where we want by changing the links before and after that spot.

Analogy: Imagine a train with cars linked front and back. To add a new car in the middle, you disconnect the two cars where you want to insert, put the new car between them, and link all three together.

null ← 1 ↔ 2 ↔ 3 -> null
          ↑
       head

Dry Run Walkthrough

Input: list: 1 ↔ 2 ↔ 3, insert value 4 at position 2 (0-based index)

Goal: Insert the value 4 between nodes 2 and 3 so the list becomes 1 ↔ 2 ↔ 4 ↔ 3

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

null ← 1 ↔ [curr->2] ↔ 3 -> null

Why: We need to reach the node after which we insert the new node

Step 2: create new node with value 4

newNode(4) created, not linked yet

Why: Prepare the new node to insert

Step 3: link new node's prev to curr (2) and next to curr's next (3)

null ← 1 ↔ 2 ↔ [newNode->4] ↔ 3 -> null

Why: Set new node's pointers to fit between 2 and 3

Step 4: update curr's next prev pointer to new node

null ← 1 ↔ 2 ↔ 4 ↔ 3 -> null

Why: Make node 3 point back to new node 4

Step 5: update curr's next pointer to new node

null ← 1 ↔ 2 ↔ 4 ↔ 3 -> null

Why: Make node 2 point forward to new node 4

Result:

null ← 1 ↔ 2 ↔ 4 ↔ 3 -> null

Annotated Code

DSA Javascript

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

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

  append(value) {
    const newNode = new Node(value);
    if (!this.head) {
      this.head = newNode;
      this.tail = newNode;
      return;
    }
    this.tail.next = newNode;
    newNode.prev = this.tail;
    this.tail = newNode;
  }

  insertAtPosition(value, position) {
    if (position < 0) return; // invalid position
    const newNode = new Node(value);
    if (position === 0) {
      // insert at head
      if (!this.head) {
        this.head = newNode;
        this.tail = newNode;
      } else {
        newNode.next = this.head;
        this.head.prev = newNode;
        this.head = newNode;
      }
      return;
    }

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

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

    newNode.next = curr.next; // link new node's next to curr's next
    if (curr.next) {
      curr.next.prev = newNode; // link next node's prev to new node
    } else {
      this.tail = newNode; // update tail if inserted at end
    }
    curr.next = newNode; // link curr's next to new node
    newNode.prev = curr; // link new node's prev to curr
  }

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

// Driver code
const dll = new DoublyLinkedList();
dll.append(1);
dll.append(2);
dll.append(3);
dll.insertAtPosition(4, 2);
console.log(dll.toString());

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

advance curr to node before insertion position to insert after it

newNode.next = curr.next; // link new node's next to curr's next

connect new node forward pointer to next node

if (curr.next) { curr.next.prev = newNode; // link next node's prev to new node } else { this.tail = newNode; // update tail if inserted at end }

update next node's backward pointer or tail if at end

curr.next = newNode; // link curr's next to new node newNode.prev = curr; // link new node's prev to curr

connect current node forward pointer and new node backward pointer

Output

1 ↔ 2 ↔ 4 ↔ 3 ↔ null

Complexity Analysis

Time: O(n) because we may need to traverse up to n nodes to reach the insertion position

Space: O(1) because we only create one new node and use a few pointers

vs Alternative: Compared to inserting at head or tail which is O(1), inserting at a specific position requires traversal, so it is slower but still efficient for linked lists compared to arrays where shifting elements is O(n)

Edge Cases

insert at position 0 in empty list

new node becomes head and tail

DSA Javascript

if (position === 0) { if (!this.head) { this.head = newNode; this.tail = newNode; }

insert at position beyond list length

no insertion happens, list unchanged

DSA Javascript

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

insert at last position (append)

new node becomes new tail

DSA Javascript

if (curr.next) { curr.next.prev = newNode; } else { this.tail = newNode; }

When to Use This Pattern

When you need to add an element exactly in the middle of a doubly linked list, use the insert at position pattern to carefully update both forward and backward links.

Common Mistakes

Mistake: Forgetting to update the prev pointer of the node after the insertion point
Fix: Always set curr.next.prev = newNode if curr.next exists

Mistake: Not handling insertion at position 0 (head) separately
Fix: Add a special case for position 0 to update head and prev pointers correctly

Summary

Inserts a new node at a given position in a doubly linked list by updating next and prev pointers.

Use when you want to add an element anywhere in the list, not just at the ends.

The key is to link the new node between the nodes before and after the target position, updating all pointers carefully.

Practice

1. What happens when you insert a new node at position 1 in a doubly linked list?

easy

A. The new node becomes the new head of the list.

B. The new node is added at the end of the list.

C. The new node replaces the last node.

D. The list remains unchanged.

Solution

1. Step 1: Understand position 1 in doubly linked list

   Position 1 means the start of the list, so the new node should be the first node.

2. Step 2: Effect of insertion at position 1

   The new node's next pointer points to the old head, and the old head's previous pointer points back to the new node. The new node becomes the head.

3. Final Answer:

   The new node becomes the new head of the list. -> Option A

4. Quick Check:

   Insert at position 1 = new head [OK]

Hint: Position 1 means new head insertion [OK]

Common Mistakes:

• Thinking position 1 means end insertion
• Not updating previous pointer of old head
• Ignoring head pointer update

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

easy

A. newNode.next = current.next; current.next.prev = newNode; current.next = newNode; newNode.prev = current;

B. newNode.prev = current.next; current.prev = newNode; newNode.next = current; current.next = newNode;

C. newNode.next = current.prev; current.next = newNode; newNode.prev = current.next;

D. newNode.prev = current; current.next = newNode; newNode.next = current.next; current.next.prev = newNode;

Solution

1. Step 1: Identify correct pointer updates for insertion

   When inserting after current, newNode.next should point to current.next, and current.next.prev should point back to newNode.

2. Step 2: Update current's next and newNode's prev

   Set current.next to newNode and newNode.prev to current to link newNode properly.

3. Final Answer:

   newNode.next = current.next; current.next.prev = newNode; current.next = newNode; newNode.prev = current; -> Option A

4. Quick Check:

   Correct pointer updates = newNode.next = current.next; current.next.prev = newNode; current.next = newNode; newNode.prev = current; [OK]

Hint: Next and prev pointers must be updated symmetrically [OK]

Common Mistakes:

• Mixing prev and next pointers
• Not updating current.next.prev
• Incorrect order of assignments causing broken links

3. Given the doubly linked list: 10 <-> 20 <-> 30 <-> null, what is the list after inserting 15 at position 2 using correct insertion logic?

medium

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

B. 15 <-> 10 <-> 20 <-> 30 <-> null

C. 10 <-> 15 <-> 20 <-> 30 <-> null

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

Solution

1. Step 1: Identify position 2 in the list

   Position 2 means after the first node (10), so 15 should be inserted between 10 and 20.

2. Step 2: Insert 15 between 10 and 20

   Update pointers so 10 points to 15, 15 points to 20, and 20's prev points to 15.

3. Final Answer:

   10 <-> 15 <-> 20 <-> 30 <-> null -> Option C

4. Quick Check:

   Insert at position 2 = between first and second node [OK]

Hint: Position 2 means after first node [OK]

Common Mistakes:

• Inserting at wrong position
• Not updating prev pointer of next node
• Breaking list links after insertion

4. Consider this code snippet to insert a node at position 3 in a doubly linked list:

let current = head;
for(let i = 1; i < pos - 1; i++) {
  current = current.next;
}
newNode.next = current.next;
current.next.prev = newNode;
current.next = newNode;
newNode.prev = current;

What error might occur if pos is greater than the list length?

medium

A. The new node is inserted at the head incorrectly.

B. Runtime error due to accessing next of null.

C. The list becomes circular causing infinite loop.

D. No error; insertion happens at the end automatically.

Solution

1. Step 1: Analyze loop for position traversal

   The loop moves current forward pos-2 times. If pos is too large, current becomes null.

2. Step 2: Accessing current.next when current is null

   Trying to access current.next.prev causes runtime error because current is null.

3. Final Answer:

   Runtime error due to accessing next of null. -> Option B

4. Quick Check:

   Out-of-range position causes null access error [OK]

Hint: Check list length before insertion [OK]

Common Mistakes:

• Not validating position against list length
• Assuming insertion at end without checks
• Ignoring null pointer exceptions

5. You have a doubly linked list: 5 <-> 10 <-> 15 <-> 20 <-> null. You want to insert a new node with value 12 at position 3. After insertion, you also want to remove the node at position 4. What will be the final list?

hard

A. 5 <-> 12 <-> 10 <-> 20 <-> null

B. 5 <-> 10 <-> 12 <-> 15 <-> 20 <-> null

C. 5 <-> 10 <-> 15 <-> 20 <-> null

D. 5 <-> 10 <-> 12 <-> 20 <-> null

Solution

1. Step 1: Insert 12 at position 3

   Position 3 means between nodes with values 10 and 15. After insertion: 5 <-> 10 <-> 12 <-> 15 <-> 20.

2. Step 2: Remove node at position 4

   Position 4 now points to node with value 15. Removing it links 12 directly to 20.

3. Final Answer:

   5 <-> 10 <-> 12 <-> 20 <-> null -> Option D

4. Quick Check:

   Insert then remove node at position 4 = 5 <-> 10 <-> 12 <-> 20 <-> null [OK]

Hint: Insert first, then remove target node [OK]

Common Mistakes:

• Removing wrong node after insertion
• Not updating pointers after removal
• Confusing positions after insertion