Why Reverse a Doubly Linked List in DSA Java?

The Big Idea

What if you could flip your entire list in just a few pointer swaps, no copying needed?

The Scenario

Imagine you have a list of your favorite songs in order, but suddenly you want to play them from last to first. Doing this by hand means rewriting the entire list backwards, which takes time and can cause mistakes.

The Problem

Manually reversing a list means you must carefully rewrite each item in reverse order. This is slow, easy to mess up, and if the list is long, it becomes a big headache.

The Solution

Reversing a doubly linked list swaps the direction of the links between nodes, so you can walk through the list backward without rewriting anything. This is fast and safe because it just changes pointers, not the data.

Before vs After

✗ Before

for (int i = list.size() - 1; i >= 0; i--) {
    System.out.println(list.get(i));
}

✓ After

Node oldHead = head;
Node current = head;
while (current != null) {
    Node temp = current.next;
    current.next = current.prev;
    current.prev = temp;
    current = temp;
}
head = tail;
tail = oldHead;

What It Enables

You can quickly reverse the order of elements in a list to access or process them backward without extra memory or copying.

Real Life Example

In a music player app, reversing the playlist order lets users switch from playing songs from first-to-last to last-to-first instantly.

Key Takeaways

Manual reversal is slow and error-prone.

Reversing a doubly linked list swaps links to reverse order efficiently.

This operation enables quick backward traversal without extra space.

Practice

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

easy

A. To change the direction of traversal so the last node becomes the first

B. To delete all nodes from the list

C. To sort the nodes in ascending order

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, allowing traversal in both directions.

2. Step 2: Purpose of reversing

   Reversing swaps the previous and next pointers of each node, making the last node the first and vice versa.

3. Final Answer:

   To change the direction of traversal so the last node becomes the first -> Option A

4. Quick Check:

   Reversing means swapping directions [OK]

Hint: Reversing flips the list direction, last becomes first [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 Java code snippets correctly swaps the next and prev pointers of a node curr in a doubly linked list?

easy

A. curr.next = curr.prev; curr.prev = null;

B. Node temp = curr.prev; curr.prev = curr.next; curr.next = null;

C. curr.next = curr.prev; curr.prev = curr.next;

D. Node temp = curr.next; curr.next = curr.prev; curr.prev = temp;

Solution

1. Step 1: Identify correct swapping logic

   Swapping two pointers requires a temporary variable to hold one pointer before overwriting it.

2. Step 2: Check each option

   A temporary variable is required to swap pointers without data loss. curr.next = curr.prev; curr.prev = null; incorrectly sets prev to null. Node temp = curr.prev; curr.prev = curr.next; curr.next = null; uses temp but wrongly sets next to null. curr.next = curr.prev; curr.prev = curr.next; overwrites without preserving original values. Node temp = curr.next; curr.next = curr.prev; curr.prev = temp; correctly swaps the pointers.

3. Final Answer:

   Node temp = curr.next; curr.next = curr.prev; curr.prev = temp; -> Option D

4. Quick Check:

   Use temp variable to swap pointers [OK]

Hint: Always use a temp variable to swap two pointers [OK]

Common Mistakes:

• Swapping without a temporary variable
• Setting one pointer to null accidentally
• Swapping pointers in wrong order

3. Given the following doubly linked list nodes and code to reverse it, what will be the printed output after reversal?

class Node {
  int data;
  Node prev, next;
  Node(int d) { data = d; prev = next = null; }
}

// List: 1 <-> 2 <-> 3
Node head = new Node(1);
Node second = new Node(2);
Node third = new Node(3);
head.next = second; second.prev = head;
second.next = third; third.prev = second;

// Reverse code snippet
Node curr = head;
Node temp = null;
while (curr != null) {
  temp = curr.prev;
  curr.prev = curr.next;
  curr.next = temp;
  curr = curr.prev;
}
if (temp != null) head = temp.prev;

// Print list forward
Node ptr = head;
while (ptr != null) {
  System.out.print(ptr.data + " ");
  ptr = ptr.next;
}

medium

A. 1 2 3

B. 3 2 1

C. 3 1 2

D. 2 3 1

Solution

1. Step 1: Understand reversal logic

   The code swaps prev and next for each node, then moves curr to the original next node (now prev after swap).

2. Step 2: Trace the list after reversal

   Original list: 1 <-> 2 <-> 3
   After reversal, head points to node with data 3.
   Printing from head forward prints: 3 2 1

3. Final Answer:

   3 2 1 -> Option B

4. Quick Check:

   Reversed list prints nodes backward [OK]

Hint: After reversal, head points to original tail node [OK]

Common Mistakes:

• Not updating head after reversal
• Confusing prev and next pointers
• Printing from old head instead of new head

4. Identify the error in the following code snippet that attempts to reverse a doubly linked list:

Node curr = head;
while (curr != null) {
  Node temp = curr.next;
  curr.next = curr.prev;
  curr.prev = temp;
  curr = curr.next;
}

medium

A. The pointers next and prev are not swapped correctly

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

C. The loop moves curr to curr.next instead of curr.prev after swapping

D. The loop condition should be curr.next != null

Solution

1. Step 1: Analyze pointer swapping

   The code swaps next and prev correctly using temp.

2. Step 2: Check loop iteration step

   After swapping, curr.next points to the original prev. To move forward in the original list, curr should move to curr.prev (which is original next). The code incorrectly moves to curr.next, causing wrong traversal.

3. Final Answer:

   The loop moves curr to curr.next instead of curr.prev after swapping -> Option C

4. Quick Check:

   Move curr to curr.prev after swapping [OK]

Hint: After swapping, move curr to curr.prev to continue traversal [OK]

Common Mistakes:

• Moving curr to wrong pointer after swap
• Confusing temp usage
• Incorrect loop condition

5. You have a doubly linked list with nodes containing integer data. After reversing the list using the standard pointer swap method, you want to find the middle node efficiently. Which approach is best to find the middle node after reversal?

hard

A. Use two pointers starting from the new head: one moves one step, the other moves two steps until the faster reaches null

B. Traverse from the original head before reversal to find the middle

C. Count nodes from the tail and divide by two to find middle index

D. Reverse the list again and then find the middle node

Solution

1. Step 1: Understand list reversal effect

   After reversal, the head points to the original tail. The list is still doubly linked and can be traversed forward.

2. Step 2: Efficient middle node finding

   The two-pointer technique (slow and fast pointers) starting from the new head finds the middle in one pass efficiently.

3. Final Answer:

   Use two pointers starting from the new head: one moves one step, the other moves two steps until the faster reaches null -> Option A

4. Quick Check:

   Two-pointer method finds middle in O(n) [OK]

Hint: Use slow and fast pointers from new head to find middle [OK]

Common Mistakes:

• Trying to find middle from old head after reversal
• Counting nodes from tail which is inefficient
• Reversing list again unnecessarily