Insert at End of Doubly Linked List in DSA Javascript - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of inserting nodes at the end of a doubly linked list

What is the printed state of the doubly linked list after inserting 10, 20, and 30 at the end?

DSA Javascript

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

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

  insertAtEnd(data) {
    const newNode = new Node(data);
    if (!this.head) {
      this.head = newNode;
      return;
    }
    let temp = this.head;
    while (temp.next) {
      temp = temp.next;
    }
    temp.next = newNode;
    newNode.prev = temp;
  }

  printList() {
    let temp = this.head;
    let result = '';
    while (temp) {
      result += temp.data + ' <-> ';
      temp = temp.next;
    }
    result += 'null';
    console.log(result);
  }
}

const dll = new DoublyLinkedList();
dll.insertAtEnd(10);
dll.insertAtEnd(20);
dll.insertAtEnd(30);
dll.printList();

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

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

C 10 <-> 20 <-> null

D null

💡 Hint

Remember that inserting at the end adds nodes after the last node, preserving order.

The insertAtEnd method adds nodes to the end of the list. After inserting 10, 20, and 30, the list is 10 <-> 20 <-> 30 <-> null.

🧠 Conceptual

intermediate

Understanding pointers in doubly linked list insertion

When inserting a new node at the end of a doubly linked list, which pointers must be updated?

A Only the new node's next pointer

B The new node's next and prev pointers, but not the last node's pointers

C Only the head pointer of the list

D The new node's prev pointer and the last node's next pointer

💡 Hint

Think about how the new node connects to the existing last node.

The new node's prev pointer must point to the last node, and the last node's next pointer must point to the new node to maintain the doubly linked structure.

🔧 Debug

advanced

Identify the bug in this insertAtEnd method

What error will this code produce when inserting nodes at the end of a doubly linked list?

DSA Javascript

insertAtEnd(data) {
  const newNode = new Node(data);
  if (!this.head) {
    this.head = newNode;
    return;
  }
  let temp = this.head;
  while (temp.next) {
    temp = temp.next;
  }
  temp.next = newNode;
  newNode.prev = temp;
}

A SyntaxError due to missing return statement

B Infinite loop because temp.next never changes

C TypeError because temp is null when list is empty

D No error, works correctly

💡 Hint

Check what happens when the list is empty and the code continues after setting head.

When the list is empty, after setting head to newNode without returning, the code continues: temp = head (newNode), while(temp.next) skips (null), then temp.next = newNode (self-loop). Subsequent insertions cause infinite loop in while(temp.next) because of the self-loop (temp.next never falsy).

❓ Predict Output

advanced

Output after inserting nodes and then traversing backwards

After inserting 5, 15, and 25 at the end, what is the output of traversing the list backwards from the last node?

DSA Javascript

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

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

  insertAtEnd(data) {
    const newNode = new Node(data);
    if (!this.head) {
      this.head = newNode;
      return;
    }
    let temp = this.head;
    while (temp.next) {
      temp = temp.next;
    }
    temp.next = newNode;
    newNode.prev = temp;
  }

  printReverse() {
    let temp = this.head;
    if (!temp) {
      console.log('null');
      return;
    }
    while (temp.next) {
      temp = temp.next;
    }
    let result = '';
    while (temp) {
      result += temp.data + ' <-> ';
      temp = temp.prev;
    }
    result += 'null';
    console.log(result);
  }
}

const dll = new DoublyLinkedList();
dll.insertAtEnd(5);
dll.insertAtEnd(15);
dll.insertAtEnd(25);
dll.printReverse();

A null

B 5 <-> 15 <-> 25 <-> null

C 25 <-> 15 <-> 5 <-> null

D 15 <-> 25 <-> 5 <-> null

💡 Hint

Traversing backwards starts from the last node and follows prev pointers.

The printReverse method moves to the last node, then prints nodes going backwards using prev pointers, resulting in 25 <-> 15 <-> 5 <-> null.

🧠 Conceptual

expert

Time complexity of inserting at the end in a doubly linked list without tail pointer

What is the time complexity of inserting a node at the end of a doubly linked list if the list does NOT maintain a tail pointer?

A O(n) because you must traverse from head to last node

B O(1) because insertion is always constant time

C O(log n) because of binary search on nodes

D O(n^2) because each insertion requires traversing all nodes twice

💡 Hint

Think about how you find the last node without a tail pointer.

Without a tail pointer, you must start at the head and traverse all nodes to reach the end, which takes O(n) time.

Practice

1. What is the main purpose of inserting a node at the end of a doubly linked list?

easy

A. To reverse the order of the nodes in the list

B. To remove the first node from the list

C. To add a new element after the last node, updating both next and previous links

D. To find the middle node of the list

Solution

1. Step 1: Understand the structure of a doubly linked list

   A doubly linked list has nodes with pointers to both the next and previous nodes, allowing traversal in both directions.

2. Step 2: Purpose of insertion at the end

   Inserting at the end means adding a new node after the current last node and updating the pointers accordingly.

3. Final Answer:

   To add a new element after the last node, updating both next and previous links -> Option C

4. Quick Check:

   Insert at end = Add after last node [OK]

Hint: Insert at end means add after last node with correct links [OK]

Common Mistakes:

• Confusing insertion at end with deletion
• Not updating previous pointer of new node
• Trying to insert at beginning instead

2. Which of the following is the correct syntax to create a new node in JavaScript for a doubly linked list?

easy

A. const newNode = new Node(value);

B. const newNode = { value: data, nextNode: null };

C. const newNode = [value, null, null];

D. const newNode = { data: value, next: null, prev: null };

Solution

1. Step 1: Identify the node structure for doubly linked list

   A node should have data, next pointer, and previous pointer properties.

2. Step 2: Check each option for correct properties

   const newNode = { data: value, next: null, prev: null }; correctly uses data, next, and prev keys with null pointers initially.

3. Final Answer:

   const newNode = { data: value, next: null, prev: null }; -> Option D

4. Quick Check:

   Node = data + next + prev [OK]

Hint: Node needs data, next, and prev keys set [OK]

Common Mistakes:

• Using wrong property names like value instead of data
• Missing prev pointer in node
• Using array instead of object for node

3. Consider the following code snippet that inserts nodes at the end of a doubly linked list. What will be the printed list after inserting 10, 20, and 30?

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

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

  insertAtEnd(data) {
    const newNode = new Node(data);
    if (!this.head) {
      this.head = newNode;
      return;
    }
    let temp = this.head;
    while (temp.next) {
      temp = temp.next;
    }
    temp.next = newNode;
    newNode.prev = temp;
  }

  printList() {
    let temp = this.head;
    let result = '';
    while (temp) {
      result += temp.data + ' -> ';
      temp = temp.next;
    }
    result += 'null';
    console.log(result);
  }
}

const dll = new DoublyLinkedList();
dll.insertAtEnd(10);
dll.insertAtEnd(20);
dll.insertAtEnd(30);
dll.printList();

medium

A. null

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

C. 10 -> 20 -> null

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

Solution

1. Step 1: Insert nodes one by one at the end

   First insert 10 as head, then 20 after 10, then 30 after 20.

2. Step 2: Print the list from head to end

   Traverse from head: 10 -> 20 -> 30 -> null is printed.

3. Final Answer:

   10 -> 20 -> 30 -> null -> Option B

4. Quick Check:

   Insert order = print order [OK]

Hint: Insert at end keeps order; print from head shows insertion order [OK]

Common Mistakes:

• Confusing insertion order with reversed output
• Not updating prev pointer causing broken links
• Printing from tail instead of head

4. The following code tries to insert a node at the end of a doubly linked list but causes an error. What is the mistake?

insertAtEnd(data) {
  const newNode = new Node(data);
  if (!this.head) {
    this.head = newNode;
  }
  let temp = this.head;
  while (temp.next) {
    temp = temp.next;
  }
  temp.next = newNode;
  newNode.prev = temp;
}

medium

A. Missing return after setting head when list is empty

B. Incorrectly assigning newNode.prev instead of newNode.next

C. Not creating newNode with correct constructor

D. Using while loop instead of for loop

Solution

1. Step 1: Analyze the empty list case

   If head is null, newNode is assigned as head but code continues to traverse and assign next pointers.

2. Step 2: Identify missing return causing duplicate insertion

   Without return after setting head, code tries to add newNode again after head, causing a cycle or error.

3. Final Answer:

   Missing return after setting head when list is empty -> Option A

4. Quick Check:

   Return after empty insert prevents duplicate links [OK]

Hint: Return immediately after empty list insertion [OK]

Common Mistakes:

• Forgetting to stop function after empty list insert
• Mixing up prev and next pointers
• Assuming loop type causes error

5. You want to insert a node with value 40 at the end of a doubly linked list that currently has nodes 10 -> 20 -> 30 -> null. After insertion, what should be the correct state of the list and the pointers of the new node?

hard

A. 10 -> 20 -> 30 -> 40 -> null, newNode.prev points to 30, newNode.next is null

B. 40 -> 10 -> 20 -> 30 -> null, newNode.prev is null, newNode.next points to 10

C. 10 -> 20 -> 30 -> null, newNode.prev and newNode.next both null

D. 10 -> 20 -> 30 -> 40 -> null, newNode.prev is null, newNode.next points to 30

Solution

1. Step 1: Insert new node at the end

   New node with value 40 is added after node 30, so 30's next points to new node.

2. Step 2: Set new node's pointers correctly

   New node's prev points to 30, and next is null because it's the last node.

3. Final Answer:

   10 -> 20 -> 30 -> 40 -> null, newNode.prev points to 30, newNode.next is null -> Option A

4. Quick Check:

   Last node's next = null, newNode.prev = previous last node [OK]

Hint: New last node prev = old last node, next = null [OK]

Common Mistakes:

• Setting newNode.prev to null incorrectly
• Placing new node at the beginning instead
• Not updating previous last node's next pointer