Reverse a Doubly Linked List in DSA Java

Mental Model

To reverse a doubly linked list, we swap the previous and next links of each node, then move forward using the old next link until all nodes are reversed.

Analogy: Imagine a train with cars connected front and back. To reverse the train, you swap the front and back connectors of each car, then move along the train to do the same for all cars.

null ← 1 ↔ 2 ↔ 3 -> null
↑head

Dry Run Walkthrough

Input: list: 1 ↔ 2 ↔ 3, reverse entire list

Goal: Reverse the list so it becomes 3 ↔ 2 ↔ 1

Step 1: Start at head node 1, swap its prev and next pointers

null -> 1 ← 2 ↔ 3 -> null
↑curr=1 (prev and next swapped)

Why: Swapping pointers reverses direction for current node

Step 2: Move curr to old next node (which is prev after swap), node 2

null ← 1 ← 2 ↔ 3 -> null
↑curr=2

Why: We use old next pointer saved in prev to continue traversal

Step 3: Swap prev and next pointers of node 2

null ← 1 ← 2 ← 3 -> null
↑curr=2 (pointers swapped)

Why: Reverse links for node 2

Step 4: Move curr to old next node (prev after swap), node 3

null ← 1 ← 2 ← 3 -> null
↑curr=3

Why: Continue traversal to next node

Step 5: Swap prev and next pointers of node 3

null ← 1 ← 2 ← 3 ← null
↑curr=3 (pointers swapped)

Why: Reverse links for last node

Step 6: Move curr to old next node (prev after swap), which is null, stop

null ← 1 ← 2 ← 3 ← null
↑curr=null, traversal ends

Why: Reached end of list after reversal

Step 7: Update head pointer to last processed node 3

null ← 3 ↔ 2 ↔ 1 -> null
↑head=3

Why: New head is the last node processed

Result:

3 ↔ 2 ↔ 1 with head at 3

Annotated Code

DSA Java

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

public class DoublyLinkedList {
    Node head;

    // Function to reverse the doubly linked list
    public void reverse() {
        Node curr = head;
        Node temp = null;

        // Traverse the list and swap prev and next for each node
        while (curr != null) {
            temp = curr.prev; // save prev
            curr.prev = curr.next; // swap prev and next
            curr.next = temp;
            curr = curr.prev; // move to next node using old next pointer
        }

        // After loop, temp points to previous node of null, which is new head
        if (temp != null) {
            head = temp.prev; // update head to new front
        }
    }

    // Helper to insert node at end
    public void append(int data) {
        Node newNode = new Node(data);
        if (head == null) {
            head = newNode;
            return;
        }
        Node curr = head;
        while (curr.next != null) {
            curr = curr.next;
        }
        curr.next = newNode;
        newNode.prev = curr;
    }

    // Helper to print list forward
    public void printList() {
        Node curr = head;
        while (curr != null) {
            System.out.print(curr.data);
            if (curr.next != null) System.out.print(" ↔ ");
            curr = curr.next;
        }
        System.out.println();
    }

    public static void main(String[] args) {
        DoublyLinkedList dll = new DoublyLinkedList();
        dll.append(1);
        dll.append(2);
        dll.append(3);

        System.out.print("Original list: ");
        dll.printList();

        dll.reverse();

        System.out.print("Reversed list: ");
        dll.printList();
    }
}

while (curr != null) {

Traverse nodes until end

temp = curr.prev;

Save current prev pointer before swap

curr.prev = curr.next;

Swap prev and next pointers to reverse links

curr.next = temp;

Complete swap of pointers

curr = curr.prev;

Move to next node using old next pointer (now in prev)

if (temp != null) { head = temp.prev; }

Update head to new front after reversal

Output

Original list: 1 ↔ 2 ↔ 3

Reversed list: 3 ↔ 2 ↔ 1

Complexity Analysis

Time: O(n) because we visit each node once to swap pointers

Space: O(1) because reversal is done in place without extra storage

vs Alternative: Compared to creating a new reversed list (O(n) time and space), this in-place reversal saves memory and is more efficient

Edge Cases

empty list

reverse does nothing, head remains null

DSA Java

while (curr != null) {

single node list

pointers swap but list remains same, head unchanged

DSA Java

while (curr != null) {

When to Use This Pattern

When asked to reverse a doubly linked list, look for swapping prev and next pointers of each node and updating the head pointer at the end.

Common Mistakes

Mistake: Moving curr to curr.next after swapping pointers instead of curr.prev
Fix: Move curr to curr.prev because after swapping, old next pointer is stored in prev

Mistake: Not updating head pointer after reversal
Fix: Update head to temp.prev after traversal to set new front

Summary

Reverses a doubly linked list by swapping each node's prev and next pointers.

Use when you need to reverse the order of nodes in a doubly linked list efficiently.

The key insight is that after swapping pointers, the old next node is accessed via the prev pointer.

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