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

Challenge - 5 Problems

❓ Predict Output

intermediate

Output after inserting nodes at the end

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

DSA Typescript

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

class DoublyLinkedList {
  head: Node | null = null;

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

  printList(): string {
    let result = '';
    let current = this.head;
    while (current) {
      result += current.data + ' <-> ';
      current = current.next;
    }
    return result + 'null';
  }
}

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

A null

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

C 10 <-> 20 <-> null

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

💡 Hint

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

The insertAtEnd method adds nodes at the end, so the list grows as 10, then 20, then 30. The printList method shows nodes from head to tail.

❓ Predict Output

intermediate

Output after inserting into an empty list

What is the printed state of the doubly linked list after inserting a single node with value 5 at the end?

DSA Typescript

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

class DoublyLinkedList {
  head: Node | null = null;

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

  printList(): string {
    let result = '';
    let current = this.head;
    while (current) {
      result += current.data + ' <-> ';
      current = current.next;
    }
    return result + 'null';
  }
}

const dll = new DoublyLinkedList();
dll.insertAtEnd(5);
console.log(dll.printList());

A null

B 5 <-> null

C 5

D 5 <-> 5 <-> null

💡 Hint

Inserting into an empty list sets the head to the new node.

Since the list was empty, the new node with value 5 becomes the head and tail. The print shows '5 <-> null'.

🔧 Debug

advanced

Identify the bug in insertAtEnd method

What error will occur when running this insertAtEnd method and why?

DSA Typescript

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

A No error, code works correctly

B Syntax error due to missing return statement

C Runtime error: Cannot read property 'next' of null because current is null when list is empty

D Logical error: new node is not linked to previous node

💡 Hint

Check what happens when the list is empty and current is assigned.

When the list is empty, head is set to newNode but code continues. current is assigned head (newNode), but since no return after setting head, the code tries to access current.next which is null, causing error.

❓ Predict Output

advanced

Output after multiple insertions and one removal

Given the code below, what is the printed state of the doubly linked list after inserting 1, 2, 3 at the end and then removing the node with value 2?

DSA Typescript

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

class DoublyLinkedList {
  head: Node | null = null;

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

  remove(data: number): void {
    let current = this.head;
    while (current) {
      if (current.data === data) {
        if (current.prev) {
          current.prev.next = current.next;
        } else {
          this.head = current.next;
        }
        if (current.next) {
          current.next.prev = current.prev;
        }
        return;
      }
      current = current.next;
    }
  }

  printList(): string {
    let result = '';
    let current = this.head;
    while (current) {
      result += current.data + ' <-> ';
      current = current.next;
    }
    return result + 'null';
  }
}

const dll = new DoublyLinkedList();
dll.insertAtEnd(1);
dll.insertAtEnd(2);
dll.insertAtEnd(3);
dll.remove(2);
console.log(dll.printList());

A 1 <-> 3 <-> null

B 1 <-> 2 <-> 3 <-> null

C 3 <-> 1 <-> null

D 1 <-> null

💡 Hint

Removing a node updates the previous and next links to skip the removed node.

Node with value 2 is removed, so the list links 1 directly to 3. The print shows '1 <-> 3 <-> null'.

🧠 Conceptual

expert

Why is updating both next and prev pointers important in doubly linked list insertion?

When inserting a new node at the end of a doubly linked list, why must we update both the previous node's next pointer and the new node's prev pointer?

A To maintain the bidirectional links so traversal works forward and backward correctly

B Only the previous node's next pointer needs updating; prev pointer is optional

C To prevent memory leaks by freeing unused nodes

D To sort the list automatically after insertion

💡 Hint

Think about how doubly linked lists allow moving in both directions.

Updating both pointers ensures the list can be traversed forward and backward without errors or broken links.

Practice

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

easy

A. To add a new element after the last node

B. To remove the first node

C. To reverse the list

D. To find the middle node

Solution

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

   A doubly linked list has nodes connected forward and backward, 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, updating pointers accordingly.

3. Final Answer:

   To add a new element after the last node -> Option A

4. Quick Check:

   Insert at end = add after last node [OK]

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

Common Mistakes:

• Confusing insertion at end with deletion
• Thinking insertion reverses the list
• Assuming insertion happens at the start

2. Which of the following TypeScript code snippets correctly initializes a new node for a doubly linked list?

easy

A. const newNode = { data: 5, next: undefined };

B. const newNode = { data: 5, next: null, prev: null };

C. const newNode = { value: 5, nextNode: null };

D. const newNode = { data: 5 };

Solution

1. Step 1: Identify required properties for a doubly linked list node

   A node must have data, next pointer, and prev pointer to link both directions.

2. Step 2: Check each option for correct properties

   const newNode = { data: 5, next: null, prev: null }; has data, next, and prev all properly set. Others miss prev or use wrong property names.

3. Final Answer:

   const newNode = { data: 5, next: null, prev: null }; -> Option B

4. Quick Check:

   Node needs data, next, prev [OK]

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

Common Mistakes:

• Omitting prev pointer
• Using wrong property names like value or nextNode
• Setting next or prev as undefined instead of null

3. Given the following TypeScript code for inserting at the end of a doubly linked list, what will be the printed list after insertion?

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

class DoublyLinkedList {
  head: Node | null = null;

  insertAtEnd(data: number) {
    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. 10 -> 20 -> 30 -> null

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

C. 10 -> 20 -> null

D. null

Solution

1. Step 1: Trace insertAtEnd calls

   First insert adds 10 as head. Second adds 20 after 10. Third adds 30 after 20.

2. Step 2: Trace printList output

   Print starts at head (10), then 20, then 30, then null.

3. Final Answer:

   10 -> 20 -> 30 -> null -> Option A

4. Quick Check:

   Inserted nodes in order = 10 -> 20 -> 30 [OK]

Hint: Insertion at end appends nodes in order [OK]

Common Mistakes:

• Confusing order and printing reversed list
• Missing last inserted node
• Printing null instead of list

4. Identify the error in the following TypeScript method for inserting at the end of a doubly linked list:

insertAtEnd(data: number) {
  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. newNode should be created outside the method

B. Incorrect assignment of newNode.prev

C. Loop condition should be temp !== null

D. Missing return after setting head when list is empty

Solution

1. Step 1: Analyze empty list case

   If head is null, method sets head to newNode but continues to loop and assign next, causing error.

2. Step 2: Fix by adding return after setting head

   Adding return after setting head prevents further code execution and avoids null pointer errors.

3. Final Answer:

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

4. Quick Check:

   Return after head set avoids errors [OK]

Hint: Return immediately after setting head if list empty [OK]

Common Mistakes:

• Not returning after setting head
• Misunderstanding loop condition
• Incorrect pointer assignments

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

hard

A. 10 <-> 20 <-> 30, with 40.prev and 40.next both null (not linked)

B. 40 <-> 10 <-> 20 <-> 30, where 40.next points to 10 and 40.prev is null

C. 10 <-> 20 <-> 30 <-> 40, where 40.prev points to 30 and 40.next is null

D. 10 <-> 20 <-> 30 <-> 40, where 40.prev and 40.next both point to null

Solution

1. Step 1: Understand insertion at end

   The new node 40 should be linked after 30, so 30.next = 40 and 40.prev = 30.

2. Step 2: Confirm pointers of new node

   Since 40 is last, 40.next must be null to mark list end.

3. Final Answer:

   10 <-> 20 <-> 30 <-> 40, where 40.prev points to 30 and 40.next is null -> Option C

4. Quick Check:

   New tail prev = old tail, next = null [OK]

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

Common Mistakes:

• Setting new node's next pointer incorrectly
• Not linking new node's prev pointer
• Inserting new node at start instead of end