Reverse a Doubly Linked List in DSA Typescript - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output after reversing this doubly linked list?

Given the doubly linked list 1 <-> 2 <-> 3 <-> 4 <-> null, what is the printed state after reversing it?

DSA Typescript

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

class DoublyLinkedList {
  head: Node | null;
  tail: Node | null;
  constructor() {
    this.head = null;
    this.tail = 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 = 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 dll = new DoublyLinkedList();
dll.append(1);
dll.append(2);
dll.append(3);
dll.append(4);
dll.reverse();
dll.printList();

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

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

C null

D 4 <-> 3 <-> 2 <-> null

💡 Hint

Think about how the next and prev pointers swap during reversal.

Reversing a doubly linked list swaps the next and prev pointers of each node. After reversal, the list order is reversed, so the head becomes the tail and vice versa.

🧠 Conceptual

intermediate

Which pointer changes are essential to reverse a doubly linked list?

To reverse a doubly linked list, which pointers must be swapped for each node?

A Swap the head and tail pointers without changing nodes

B Only update the next pointers to point backwards

C Only update the prev pointers to point forwards

D Swap the next and prev pointers of each node

💡 Hint

Remember each node has two pointers: next and prev.

Reversing requires swapping both next and prev pointers for each node to reverse the direction of the list.

🔧 Debug

advanced

What error occurs when running this reverse function on a doubly linked list?

Identify the error in the reverse method below and its effect.

DSA Typescript

reverse() {
  let current = this.head;
  while (current) {
    let temp = current.next;
    current.next = current.prev;
    current.prev = temp;
    current = current.next;
  }
  this.head = current;
}

A The head becomes null, resulting in an empty list after reversal

B TypeError because current.next is undefined

C Infinite loop due to incorrect pointer update

D No error, the list reverses correctly

💡 Hint

Check how current is updated and what happens to head at the end.

The head is set to current after the loop, but current is null at loop end, so head becomes null and list appears empty.

❓ Predict Output

advanced

What is the output of this reversed doubly linked list print?

After reversing the list 10 <-> 20 <-> 30, what does the printList method output?

DSA Typescript

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

class DoublyLinkedList {
  head: Node | null;
  tail: Node | null;
  constructor() {
    this.head = null;
    this.tail = 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 = 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 dll = new DoublyLinkedList();
dll.append(10);
dll.append(20);
dll.append(30);
dll.reverse();
dll.printList();

A null

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

C 30 <-> 20 <-> 10 <-> null

D 30 <-> 20 <-> null

💡 Hint

Trace the pointer swaps carefully for each node.

Reversing swaps next and prev pointers, so the list order reverses from 10->20->30 to 30->20->10.

🧠 Conceptual

expert

Why is it necessary to update the head pointer after reversing a doubly linked list?

After swapping next and prev pointers for all nodes, why must the head pointer be updated?

A Because the head pointer always points to null after reversal

B Because the original head becomes the tail, so head must point to the new first node

C Because the tail pointer automatically updates the head pointer

D Because the list becomes circular and head must be reset

💡 Hint

Think about what happens to the first node after reversal.

Reversing swaps directions, so the original head is now the last node. The head pointer must be updated to the new first node to maintain list integrity.

Practice

1. What is the main purpose of reversing a doubly linked list?

easy

A. To sort the nodes in ascending order

B. To reverse the order of nodes so the last becomes first and vice versa

C. To delete all nodes from the list

D. To convert it into a singly linked list

Solution

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

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

2. Step 2: Purpose of reversing

   Reversing swaps the direction so the last node becomes the first and the first becomes the last.

3. Final Answer:

   To reverse the order of nodes so the last becomes first and vice versa -> Option B

4. Quick Check:

   Reversing = changing node order [OK]

Hint: Reversing flips the list order, not deleting or sorting [OK]

Common Mistakes:

• Confusing reversing with deleting nodes
• Thinking reversing sorts the list
• Assuming it converts to singly linked list

2. Which of the following TypeScript code snippets correctly swaps the next and prev pointers of a node in a doubly linked list?

easy

A. let temp = node.next; node.next = node.prev; node.prev = temp;

B. node.next = node.next; node.prev = node.prev;

C. node.prev = node.next; node.next = node.prev;

D. let temp = node.prev; node.prev = node.next; node.next = temp.next;

Solution

1. Step 1: Identify correct swapping logic

   Swapping pointers requires a temporary variable to hold one pointer before assignment.

2. Step 2: Check each option

   let temp = node.next; node.next = node.prev; node.prev = temp; correctly uses a temp variable to swap next and prev. Others either assign incorrectly or lose references.

3. Final Answer:

   let temp = node.next; node.next = node.prev; node.prev = temp; -> Option A

4. Quick Check:

   Swap pointers using temp variable [OK]

Hint: Use a temp variable to swap pointers safely [OK]

Common Mistakes:

• Assigning pointers without temp causes data loss
• Mixing up next and prev assignments
• Using incorrect pointer references

3. What will be the output of the following TypeScript code that reverses a doubly linked list?

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

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

// Create list: 1 <-> 2 <-> 3
const n1 = new Node(1);
const n2 = new Node(2);
n1.next = n2; n2.prev = n1;
const n3 = new Node(3);
n2.next = n3; n3.prev = n2;

const newHead = reverse(n1);

// Print reversed list
let result = [];
let node = newHead;
while (node !== null) {
  result.push(node.data);
  node = node.next;
}
console.log(result);

medium

A. []

B. [1, 2, 3]

C. [3, 2, 1]

D. [3, 1, 2]

Solution

1. Step 1: Trace pointer swaps in the loop

   Each node swaps its next and prev. The loop moves forward using the old next pointer now in prev.

2. Step 2: Update head to new first node

   After loop, head is updated to last node processed, which is node with data 3.

3. Final Answer:

   [3, 2, 1] -> Option C

4. Quick Check:

   Reversed list order = [3, 2, 1] [OK]

Hint: Reversing swaps pointers and updates head to last node [OK]

Common Mistakes:

• Not updating head after reversal
• Confusing next and prev in loop
• Printing original list order

4. Identify the bug in this TypeScript function that attempts to reverse a doubly linked list:

function reverse(head: Node | null): Node | null {
  let current = head;
  while (current !== null) {
    let temp = current.next;
    current.next = current.prev;
    current.prev = temp;
    current = current.next;
  }
  return head;
}

medium

A. The function should return current instead of head

B. The pointers next and prev are swapped incorrectly

C. The loop condition should be current.next !== null

D. The function does not update the head to the new first node after reversal

Solution

1. Step 1: Check pointer swapping logic

   The swapping of next and prev is correct using a temp variable.

2. Step 2: Verify head update after reversal

   The function returns original head without updating it to the new first node, so the reversed list head is incorrect.

3. Final Answer:

   The function does not update the head to the new first node after reversal -> Option D

4. Quick Check:

   Head must update to new first node [OK]

Hint: Always update head to last processed node after reversal [OK]

Common Mistakes:

• Forgetting to update head after reversal
• Returning old head instead of new head
• Incorrect loop condition causing infinite loop

5. Given a doubly linked list with nodes containing integer data, how would you modify the reversal function to also count how many nodes were reversed and return both the new head and the count?

hard

A. Modify the function to use an object return type like { head: Node | null, count: number }, increment count inside the loop, and update head after reversal.

B. Add a global variable to count nodes and return only the new head.

C. Count nodes before reversal and return the count without changing the function.

D. Return an array with the reversed list nodes and count without modifying the reversal logic.

Solution

1. Step 1: Add a counter variable inside the reversal function

   Initialize a count variable to zero and increment it each time a node is processed in the reversal loop.

2. Step 2: Return both new head and count

   After reversal, return an object containing the updated head and the count of nodes reversed.

3. Final Answer:

   Modify the function to use an object return type like { head: Node | null, count: number }, increment count inside the loop, and update head after reversal. -> Option A

4. Quick Check:

   Return head and count together after reversal [OK]

Hint: Use an object return type to return multiple values [OK]

Common Mistakes:

• Using global variables instead of local counters
• Not updating head before returning
• Returning count without reversing