Insert at Specific Position in Doubly Linked List in DSA Javascript - Execution Trace

Concept Flow - Insert at Specific Position in Doubly Linked List

Create new node with value

↓

Check if position is 1

↓

Insert at head

↓

Traverse to position-1 node

↓

Adjust pointers: prev, next

↓

Insert node

↓

Done

Create a new node, then either insert at head if position is 1, or traverse to the node before the position and adjust pointers to insert the new node.

Execution Sample

DSA Javascript

function insertAtPosition(head, value, position) {
  let newNode = { val: value, prev: null, next: null };
  if (position === 1) {
    newNode.next = head;
    if (head) head.prev = newNode;
    return newNode;
  }
  let current = head;
  for (let i = 1; i < position - 1 && current; i++) current = current.next;
  if (!current) return head;
  newNode.next = current.next;
  if (current.next) current.next.prev = newNode;
  current.next = newNode;
  newNode.prev = current;
  return head;
}

Inserts a new node with given value at the specified position in a doubly linked list.

Execution Table

Step	Operation	Current Node	Pointer Changes	Visual State
1	Create new node with value=5	null	newNode = {5, prev:null, next:null}	null
2	Check if position=1	head=1	No pointer change	1 <-> 2 <-> 3 <-> null
3	Traverse to position-1 node	current=1	No pointer change	1 <-> 2 <-> 3 <-> null
4	Traverse to next node	current=2	No pointer change	1 <-> 2 <-> 3 <-> null
5	Set newNode.next = current.next (3)	current=2	newNode.next = 3	1 <-> 2 <-> 3 <-> null
6	Set current.next.prev = newNode	current=2	3.prev = newNode	1 <-> 2 <-> 3 <-> null
7	Set current.next = newNode	current=2	2.next = newNode	1 <-> 2 <-> 5 <-> 3 <-> null
8	Set newNode.prev = current	current=2	newNode.prev = 2	1 <-> 2 <-> 5 <-> 3 <-> null
9	Return head	head=1	No pointer change	1 <-> 2 <-> 5 <-> 3 <-> null

💡 Insertion complete at position 3; list updated with new node 5.

Variable Tracker

Variable	Start	After Step 1	After Step 3	After Step 5	After Step 7	Final
head	1 <-> 2 <-> 3 <-> null	1 <-> 2 <-> 3 <-> null	1 <-> 2 <-> 3 <-> null	1 <-> 2 <-> 3 <-> null	1 <-> 2 <-> 5 <-> 3 <-> null	1 <-> 2 <-> 5 <-> 3 <-> null
current	null	null	1	2	2	2
newNode	null	{5, prev:null, next:null}	{5, prev:null, next:null}	{5, prev:null, next:3}	{5, prev:null, next:3}	{5, prev:2, next:3}

Key Moments - 3 Insights

Why do we traverse to position-1 node before inserting?

Because we need to adjust pointers of the node before the insertion point to link the new node correctly, as shown in steps 3-7 in the execution table.

What happens if position is 1?

The new node becomes the new head, its next points to old head, and old head's prev points back to new node, as shown in the concept flow and handled in code step 2.

Why do we check if current.next exists before setting current.next.prev?

To avoid errors when inserting at the end of the list where current.next is null, so we only update prev pointer if next node exists, as in step 6.

Visual Quiz - 3 Questions

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

A Node with value 1

B Node with value 3

C Node with value 2

D null

💡 Hint

Check the 'Current Node' column at step 4 in the execution table.

At which step is the new node's prev pointer set?

A Step 6

B Step 8

C Step 7

D Step 5

💡 Hint

Look at the 'Pointer Changes' column to find when newNode.prev is assigned.

If we insert at position 1, what will be the new head's next node?

A Old head node

B null

C New node itself

D Second node in original list

💡 Hint

Refer to the concept flow and code where position === 1 is handled.

Concept Snapshot

Insert at Specific Position in Doubly Linked List:
- Create new node
- If position=1, insert at head
- Else traverse to position-1 node
- Adjust pointers: newNode.next, newNode.prev, current.next, current.next.prev
- Return head
- Handles insertion at middle or end
- Maintains bidirectional links

Full Transcript

To insert a node at a specific position in a doubly linked list, first create the new node. If the position is 1, insert the new node at the head by linking it before the current head. Otherwise, traverse the list to the node just before the desired position. Then adjust the pointers: set the new node's next to current's next, set the next node's prev to new node if it exists, set current's next to new node, and set new node's prev to current. Finally, return the head of the list. This process ensures the doubly linked list remains properly linked in both directions after insertion.

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