Reverse a Doubly Linked List in DSA Java - Build from Scratch

Reverse a Doubly Linked List

📖 Scenario: You are working on a music playlist app. The playlist is stored as a doubly linked list where each node holds a song name. Sometimes, users want to reverse the order of songs to listen from the last added to the first.

🎯 Goal: Build a program that creates a doubly linked list of songs, then reverses the list so the last song becomes the first, and prints the reversed list.

📋 What You'll Learn

Create a doubly linked list with exactly these songs in order: "SongA", "SongB", "SongC", "SongD"

Create a variable called head that points to the first node of the list

Write a method called reverseList that reverses the doubly linked list starting from head

Print the reversed list starting from the new head, showing song names separated by " <-> " and ending with "null"

💡 Why This Matters

🌍 Real World

Doubly linked lists are used in music players, browsers, and other apps to allow easy forward and backward navigation through items.

💼 Career

Understanding how to manipulate doubly linked lists is important for software developers working on data structures, system design, and performance optimization.

1

Create the doubly linked list with songs

Create a class called Node with String song, Node next, and Node prev. Then create four nodes with songs "SongA", "SongB", "SongC", and "SongD". Link them to form a doubly linked list in this order. Finally, create a variable called head that points to the first node.

DSA Java

// Define Node class and create doubly linked list nodes
// Link nodes to form doubly linked list
// Set head to first node

Hint

Remember to link each node's next and prev pointers correctly to form the doubly linked list.

2

Add a method to reverse the doubly linked list

Inside the Main class, add a static method called reverseList that takes a Node head parameter and returns the new head after reversing the list. The method should swap the next and prev pointers for each node while traversing the list.

DSA Java

class Node {
    String song;
    Node next;
    Node prev;

    Node(String song) {
        this.song = song;
        this.next = null;
        this.prev = null;
    }
}

public class Main {
    public static Node reverseList(Node head) {
        // Your code here
    }

    public static void main(String[] args) {
        Node node1 = new Node("SongA");
        Node node2 = new Node("SongB");
        Node node3 = new Node("SongC");
        Node node4 = new Node("SongD");

        node1.next = node2;
        node2.prev = node1;
        node2.next = node3;
        node3.prev = node2;
        node3.next = node4;
        node4.prev = node3;

        Node head = node1;
    }
}

Hint

Swap the next and prev pointers for each node. Move forward using the old prev pointer after swapping.

3

Call the reverse method and update head

In the main method, call the reverseList method with head as argument and assign the result back to head.

DSA Java

class Node {
    String song;
    Node next;
    Node prev;

    Node(String song) {
        this.song = song;
        this.next = null;
        this.prev = null;
    }
}

public class Main {
    public static Node reverseList(Node head) {
        Node current = head;
        Node temp = 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;
    }

    public static void main(String[] args) {
        Node node1 = new Node("SongA");
        Node node2 = new Node("SongB");
        Node node3 = new Node("SongC");
        Node node4 = new Node("SongD");

        node1.next = node2;
        node2.prev = node1;
        node2.next = node3;
        node3.prev = node2;
        node3.next = node4;
        node4.prev = node3;

        Node head = node1;
        // Your code here
    }
}

Hint

Assign the result of reverseList(head) back to head to update the list start.

4

Print the reversed doubly linked list

Add a printList static method in the Main class that takes Node head and prints the songs in order separated by " <-> ", ending with "null". Then call printList(head) in main after reversing the list.

DSA Java

class Node {
    String song;
    Node next;
    Node prev;

    Node(String song) {
        this.song = song;
        this.next = null;
        this.prev = null;
    }
}

public class Main {
    public static Node reverseList(Node head) {
        Node current = head;
        Node temp = 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;
    }

    public static void printList(Node head) {
        // Your code here
    }

    public static void main(String[] args) {
        Node node1 = new Node("SongA");
        Node node2 = new Node("SongB");
        Node node3 = new Node("SongC");
        Node node4 = new Node("SongD");

        node1.next = node2;
        node2.prev = node1;
        node2.next = node3;
        node3.prev = node2;
        node3.next = node4;
        node4.prev = node3;

        Node head = node1;
        head = reverseList(head);
        // Your code here
    }
}

Hint

Traverse from head using next and print each song followed by " <-> ". End with "null".

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