Create and Initialize Doubly Linked List in DSA Typescript - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Doubly Linked List after Insertions

What is the printed state of the doubly linked list after inserting nodes with values 10, 20, and 30 in order?

DSA Typescript

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

class DoublyLinkedList {
  head: Node | null = null;
  tail: Node | null = null;

  append(value: number) {
    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;
  }

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

const list = new DoublyLinkedList();
list.append(10);
list.append(20);
list.append(30);
list.printList();

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

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

C 10 -> 20 -> 30 -> null

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

💡 Hint

Trace the append method and how nodes link forward and backward.

The append method adds nodes to the end of the list. The printList method prints values from head to tail separated by ' <-> '. So the output shows 10 linked to 20 linked to 30, ending with null.

❓ Predict Output

intermediate

State of Doubly Linked List after Removing Head

What is the printed state of the doubly linked list after removing the head node from the list containing 5, 15, 25?

DSA Typescript

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

class DoublyLinkedList {
  head: Node | null = null;
  tail: Node | null = null;

  append(value: number) {
    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;
  }

  removeHead() {
    if (!this.head) return;
    if (this.head === this.tail) {
      this.head = null;
      this.tail = null;
      return;
    }
    this.head = this.head.next;
    if (this.head) this.head.prev = null;
  }

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

const list = new DoublyLinkedList();
list.append(5);
list.append(15);
list.append(25);
list.removeHead();
list.printList();

A null

B 15 <-> 25 <-> null

C 25 <-> 15 <-> null

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

💡 Hint

Removing head moves the head pointer to the next node and updates links.

After removing the head (5), the new head is 15. The list prints from 15 to 25 ending with null.

🔧 Debug

advanced

Identify the Bug in Doubly Linked List Append Method

What error will occur when running this code that tries to append nodes to a doubly linked list?

DSA Typescript

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

class DoublyLinkedList {
  head: Node | null = null;
  tail: Node | null = null;

  append(value: number) {
    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;
  }
}

const list = new DoublyLinkedList();
list.append(1);
list.append(2);

A TypeError: Cannot read property 'next' of null

B SyntaxError: Unexpected token '.'

C No error, code runs correctly

D ReferenceError: tail is not defined

💡 Hint

Check how 'tail' is accessed and if it can be null.

The code uses 'this.tail.next' without checking if 'this.tail' is null. On the first append, tail is set, but on the second append, if tail was null, accessing 'next' causes a TypeError.

❓ Predict Output

advanced

Output after Reversing a Doubly Linked List

What is the printed state of the doubly linked list after reversing it? Initial list: 1 <-> 2 <-> 3 <-> null

DSA Typescript

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

class DoublyLinkedList {
  head: Node | null = null;
  tail: Node | null = null;

  append(value: number) {
    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;
  }

  reverse() {
    let current = this.head;
    let temp: Node | null = null;
    while (current) {
      temp = current.prev;
      current.prev = current.next;
      current.next = temp;
      current = current.prev;
    }
    if (temp) {
      this.head = temp.prev;
    }
  }

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

const list = new DoublyLinkedList();
list.append(1);
list.append(2);
list.append(3);
list.reverse();
list.printList();

A 3 <-> 2 <-> 1 <-> null

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

C 1 <-> 3 <-> 2 <-> null

D null

💡 Hint

The reverse method swaps next and prev pointers and updates head.

The reverse method swaps the next and prev pointers of each node and then updates the head to the last node processed. This reverses the list order.

🧠 Conceptual

expert

Number of Nodes after Multiple Insertions and Deletions

A doubly linked list starts empty. We perform these operations in order: append(4), append(7), append(9), removeHead(), append(10), removeTail(). How many nodes remain in the list?

A 2

B 3

C 1

D 4

💡 Hint

Track the list size after each operation carefully.

Operations step-by-step:
append(4) → list: 4
append(7) → list: 4 <-> 7
append(9) → list: 4 <-> 7 <-> 9
removeHead() removes 4 → list: 7 <-> 9
append(10) → list: 7 <-> 9 <-> 10
removeTail() removes 10 → list: 7 <-> 9
Remaining nodes: 2

Practice

1. What is the main difference between a doubly linked list and a singly linked list?

easy

A. A doubly linked list stores data in arrays instead of nodes.

B. A doubly linked list does not use pointers at all.

C. A doubly linked list can only be traversed forward.

D. A doubly linked list has nodes with pointers to both previous and next nodes.

Solution

1. Step 1: Understand node structure in doubly linked list

   Each node in a doubly linked list contains data and two pointers: one to the previous node and one to the next node.

2. Step 2: Compare with singly linked list

   A singly linked list node has only one pointer to the next node, so it can only be traversed forward.

3. Final Answer:

   A doubly linked list has nodes with pointers to both previous and next nodes. -> Option D

4. Quick Check:

   Doubly linked list = two pointers per node [OK]

Hint: Remember: doubly means two pointers per node [OK]

Common Mistakes:

• Thinking doubly linked list uses arrays
• Assuming it can only go forward
• Confusing pointer usage

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

easy

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

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

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

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

Solution

1. Step 1: Check for both next and prev pointers

   class Node { data: number; next: Node | null; prev: Node | null; constructor(data: number) { this.data = data; this.next = null; this.prev = null; } } defines both next and prev as Node or null, which is correct for doubly linked list nodes.

2. Step 2: Verify constructor initialization

   class Node { data: number; next: Node | null; prev: Node | null; constructor(data: number) { this.data = data; this.next = null; this.prev = null; } } initializes next and prev to null, which is proper for a new node.

3. Final Answer:

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

4. Quick Check:

   Node class needs next and prev pointers [OK]

Hint: Look for both next and prev properties initialized to null [OK]

Common Mistakes:

• Missing prev pointer in node class
• Using wrong types for pointers
• Initializing pointers with numbers instead of null

3. What will be the output of the following TypeScript code that creates a doubly linked list with nodes 10, 20, 30 and prints the list forward?

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

class DoublyLinkedList {
  head: Node | null = null;

  append(data: number) {
    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;
  }

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

const list = new DoublyLinkedList();
list.append(10);
list.append(20);
list.append(30);
list.printForward();

medium

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

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

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

D. 10 -> 20 -> null

Solution

1. Step 1: Append nodes 10, 20, 30 in order

   Nodes are added at the end, so list order is 10, then 20, then 30.

2. Step 2: Print list forward

   printForward traverses from head to next nodes, printing data with arrows, ending with null.

3. Final Answer:

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

4. Quick Check:

   Appending adds to tail, printForward shows 10 to 30 [OK]

Hint: Appending adds nodes at tail; printForward shows head to tail [OK]

Common Mistakes:

• Confusing print order as reversed
• Missing last node in output
• Printing null at start instead of end

4. Identify the error in the following TypeScript code that tries to append a node to a doubly linked list:

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

class DoublyLinkedList {
  head: Node | null = null;

  append(data: number) {
    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;
    // Missing line here
  }
}

medium

A. The code misses setting newNode.prev to current before appending.

B. The code should set head to newNode even if head exists.

C. The constructor should initialize next and prev to undefined, not null.

D. The while loop should check current.prev instead of current.next.

Solution

1. Step 1: Check append logic for doubly linked list

   When appending, newNode.prev must point to current (the last node) to maintain backward link.

2. Step 2: Identify missing pointer assignment

   The code sets current.next = newNode but does not set newNode.prev = current, breaking backward link.

3. Final Answer:

   The code misses setting newNode.prev to current before appending. -> Option A

4. Quick Check:

   newNode.prev must link to previous node [OK]

Hint: Always set newNode.prev = last node when appending [OK]

Common Mistakes:

• Forgetting to set newNode.prev
• Changing head incorrectly
• Checking wrong pointer in loop

5. You want to create a doubly linked list from an array of numbers [5, 15, 25] and then reverse the list by changing pointers (not data). Which sequence of pointer changes correctly reverses the list?

hard

A. For each node, set next to prev and leave prev unchanged; head remains same.

B. For each node, set next to null and prev to null; then append nodes in reverse order.

C. For each node, swap its next and prev pointers; then update head to last node.

D. For each node, swap data values instead of pointers; head stays unchanged.

Solution

1. Step 1: Understand reversing a doubly linked list by pointers

   Reversing means for each node, next and prev pointers must be swapped to reverse direction.

2. Step 2: Update head pointer

   After swapping pointers, head must point to the original tail (last node) to reflect new start.

3. Final Answer:

   For each node, swap its next and prev pointers; then update head to last node. -> Option C

4. Quick Check:

   Swap next and prev, then reset head [OK]

Hint: Swap next and prev pointers on all nodes, then reset head [OK]

Common Mistakes:

• Only swapping data, not pointers
• Not updating head after reversal
• Setting pointers to null incorrectly