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

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of reversing a doubly linked list with 3 nodes

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

DSA Javascript

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

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

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

  reverse() {
    let curr = this.head;
    let temp = null;
    while (curr) {
      temp = curr.prev;
      curr.prev = curr.next;
      curr.next = temp;
      curr = curr.prev;
    }
    if (temp) {
      this.head = temp.prev;
    }
  }

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

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

A 3 -> null

B 1 -> 2 -> 3 -> null

C null

D 3 -> 2 -> 1 -> null

💡 Hint

Think about how reversing swaps next and prev pointers.

Reversing swaps the next and prev pointers of each node. The head moves to the last node, so the list prints 3 -> 2 -> 1 -> null.

❓ Predict Output

intermediate

Output after reversing an empty doubly linked list

What is the output when reversing and printing an empty doubly linked list?

DSA Javascript

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

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

  reverse() {
    let curr = this.head;
    let temp = null;
    while (curr) {
      temp = curr.prev;
      curr.prev = curr.next;
      curr.next = temp;
      curr = curr.prev;
    }
    if (temp) {
      this.head = temp.prev;
    }
  }

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

const dll = new DoublyLinkedList();
dll.reverse();
dll.printList();

A Error: Cannot read property 'prev' of null

B null

C -> null

D Empty list

💡 Hint

Check what happens when head is null.

Since the list is empty, head is null. The reverse method does nothing and printList prints 'null'.

🔧 Debug

advanced

Identify the bug in this reverse method for doubly linked list

What is the bug in this reverse method that causes incorrect reversal?

DSA Javascript

reverse() {
  let curr = this.head;
  let temp = null;
  while (curr) {
    temp = curr.next;
    curr.next = curr.prev;
    curr.prev = temp;
    curr = curr.next;
  }
  if (temp) {
    this.head = temp.prev;
  }
}

A The variable temp should store curr.prev, not curr.next

B The head should be updated to temp.next, not temp.prev

C The loop should use curr.prev instead of curr.next to move forward

D The method is correct; no bug present

💡 Hint

Check what temp stores before swapping pointers.

The code stores curr.next in temp but should store curr.prev to swap pointers correctly. This causes incorrect reversal.

❓ Predict Output

advanced

Output after reversing a doubly linked list with one node

What is the printed output after reversing a doubly linked list with a single node containing 5?

DSA Javascript

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

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

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

  reverse() {
    let curr = this.head;
    let temp = null;
    while (curr) {
      temp = curr.prev;
      curr.prev = curr.next;
      curr.next = temp;
      curr = curr.prev;
    }
    if (temp) {
      this.head = temp.prev;
    }
  }

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

const dll = new DoublyLinkedList();
dll.append(5);
dll.reverse();
dll.printList();

A 5 -> 5 -> null

B null

C 5 -> null

D Error: Cannot read property 'prev' of null

💡 Hint

Reversing a single node list should not change the list.

A single node reversed remains the same. The output prints '5 -> null'.

🧠 Conceptual

expert

Why does reversing a doubly linked list require swapping next and prev pointers?

Choose the best explanation for why reversing a doubly linked list involves swapping the next and prev pointers of each node.

A Because swapping next and prev pointers reverses the direction of traversal, making the last node the new head.

B Because only swapping next pointers is enough to reverse the list, prev pointers are swapped for optimization.

C Because swapping pointers deletes the original list and creates a new reversed list from scratch.

D Because swapping next and prev pointers sorts the list in ascending order.

💡 Hint

Think about how traversal direction changes after reversal.

Swapping next and prev pointers reverses the links between nodes, so traversal direction reverses and the last node becomes the new head.

Practice

1. What does reversing a doubly linked list mean?

easy

A. Adding a new node at the end

B. Deleting all nodes from the list

C. Sorting the nodes in ascending order

D. Swapping the next and previous pointers of each node

Solution

1. Step 1: Understand doubly linked list structure

   Each node has two pointers: one to the next node and one to the previous node.

2. Step 2: Reverse means swapping pointers

   Reversing means changing each node's next pointer to previous and previous pointer to next.

3. Final Answer:

   Swapping the next and previous pointers of each node -> Option D

4. Quick Check:

   Reverse = swap next and prev pointers [OK]

Hint: Reverse means swap next and prev pointers [OK]

Common Mistakes:

• Thinking reverse means deleting nodes
• Confusing reverse with sorting
• Adding nodes instead of reversing pointers

2. Which of the following is the correct way to swap the next and prev pointers of a node in JavaScript?

easy

A. node.prev = node.next; node.next = node.prev;

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

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

D. node.next = node.next; node.prev = node.prev;

Solution

1. Step 1: Use a temporary variable to hold one pointer

   Store node.next in temp to avoid losing its value.

2. Step 2: Swap pointers correctly

   Assign node.next = node.prev, then node.prev = temp to complete swap.

3. Final Answer:

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

4. Quick Check:

   Swap with temp variable = correct [OK]

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

Common Mistakes:

• Swapping without temp loses pointer data
• Assigning both pointers to same value
• Not swapping pointers at all

3. What will be the output list after reversing this doubly linked list?

Head -> 1 <-> 2 <-> 3 <-> null

After reversal, what is the new head node's value?

medium

A. 3

B. 1

C. 2

D. null

Solution

1. Step 1: Original list order

   List is 1 <-> 2 <-> 3, head points to 1.

2. Step 2: Reverse swaps pointers, so last node becomes head

   After reversal, 3 becomes the new head, pointing backward to 2 and forward to null.

3. Final Answer:

   3 -> Option A

4. Quick Check:

   New head after reverse = last node = 3 [OK]

Hint: New head after reverse is original tail [OK]

Common Mistakes:

• Assuming head stays same after reverse
• Confusing node values order
• Thinking null becomes head

4. Identify the bug in this reverse function for a doubly linked list:

function reverse(head) {
  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 does not update the head to the new first node

B. Swapping next and prev pointers is done incorrectly

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

D. The function should return null instead of head

Solution

1. Step 1: Check pointer swapping

   Swapping next and prev pointers is done correctly using temp variable.

2. Step 2: Check head update after reversal

   Function returns original head, but after reversal head should be last node visited, so head is not updated.

3. Final Answer:

   The function does not update the head to the new first node -> Option A

4. Quick Check:

   Head must update to new first node [OK]

Hint: Update head to last processed node after loop [OK]

Common Mistakes:

• Not updating head after reversal
• Incorrect loop condition causing infinite loop
• Returning wrong node at end

5. Given a doubly linked list with nodes:

Head -> 10 <-> 20 <-> 30 <-> 40 <-> null

After reversing the list, what is the correct sequence of nodes starting from the new head?

hard

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

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

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

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

Solution

1. Step 1: Original list order

   Nodes are linked as 10 <-> 20 <-> 30 <-> 40, head at 10.

2. Step 2: Reverse swaps pointers and changes head to last node

   After reversal, head is 40, and nodes link backward as 40 <-> 30 <-> 20 <-> 10.

3. Final Answer:

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

4. Quick Check:

   Reverse list order = original tail to head [OK]

Hint: Reversed list order is original list backwards [OK]

Common Mistakes:

• Not reversing the order correctly
• Mixing node values in wrong order
• Confusing null placement in list