Insert at Specific Position in Doubly Linked List in DSA Javascript - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create a new node with the given value.

DSA Javascript

class Node {
  constructor(value) {
    this.data = [1];
    this.prev = null;
    this.next = null;
  }
}

Drag options to blanks, or click blank then click option'

Avalue

Bval

Cdata

Dnode

Attempts:

3 left

💡 Hint

Common Mistakes

Using a variable name not defined in the constructor.

Assigning this.data to null or undefined.

The constructor receives the value as 'value', so we assign it to this.data.

2fill in blank

medium

Complete the code to check if the position to insert is at the head (position 1).

DSA Javascript

if (position === [1]) {
  newNode.next = this.head;
  if (this.head !== null) {
    this.head.prev = newNode;
  }
  this.head = newNode;
  return;
}

Drag options to blanks, or click blank then click option'

Anull

B1

C-1

D0

Attempts:

3 left

💡 Hint

Common Mistakes

Checking for position 0 instead of 1.

Using null or undefined in the comparison.

Position 1 means inserting at the head of the list.

3fill in blank

hard

Fix the error in the loop condition to find the node before the insertion position.

DSA Javascript

let current = this.head;
let count = 1;
while (count < [1] - 1 && current !== null) {
  current = current.next;
  count++;
}

Drag options to blanks, or click blank then click option'

Apos

Blength

Cindex

Dposition

Attempts:

3 left

💡 Hint

Common Mistakes

Using undefined variables like 'pos' or 'index'.

Looping until position instead of position - 1.

The variable 'position' holds the target insertion position.

4fill in blank

hard

Fill both blanks to correctly insert the new node between nodes.

DSA Javascript

newNode.next = current.[1];
if (current.[2] !== null) {
  current.[2].prev = newNode;
}
current.next = newNode;
newNode.prev = current;

Drag options to blanks, or click blank then click option'

Anext

Bprev

Chead

Dtail

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'prev' instead of 'next' for newNode.next.

Not updating the prev pointer of the next node.

We set newNode.next to current.next and update current.next.prev to newNode.

5fill in blank

hard

Fill the two blanks to complete the insertAtPosition method.

DSA Javascript

insertAtPosition(value, position) {
  const newNode = new Node([1]);
  if (position === [2]) {
    newNode.next = this.head;
    if (this.head !== null) {
      this.head.prev = newNode;
    }
    this.head = newNode;
    return;
  }
  let current = this.head;
  let count = 1;
  while (count < position - 1 && current !== null) {
    current = current.next;
    count++;
  }
  if (current === null) {
    return;
  }
  newNode.next = current.next;
  if (current.next !== null) {
    current.next.prev = newNode;
  }
  current.next = newNode;
  newNode.prev = current;
}

Drag options to blanks, or click blank then click option'

Avalue

B1

C0

DnewNode

Attempts:

3 left

💡 Hint

Common Mistakes

Passing wrong variable to Node constructor.

Checking position against 0 instead of 1.

We pass 'value' to Node, check if position is 1, and use 0 as a distractor.

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