Reverse a Doubly Linked List in DSA Java - Execution Trace

Concept Flow - Reverse a Doubly Linked List

Start at head node

↓

Swap prev and next pointers

↓

Move to original next node (now prev)

↓

Repeat until current node is null

↓

Update head to last processed node

↓

Done: list reversed

We start at the head, swap each node's prev and next pointers, move forward using the original next pointer, and finally update the head to complete reversal.

Execution Sample

DSA Java

Node reverse(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;
}

This code reverses the doubly linked list by swapping prev and next pointers of each node and updating the head.

Execution Table

Step	Operation	Current Node	Pointer Changes	Visual State
1	Start at head	Node 1	None	1 <-> 2 <-> 3 <-> 4 <-> null
2	Swap prev and next of Node 1	Node 1	prev: null -> 2, next: 2 -> null	1 <- 2 <-> 3 <-> 4 <-> null
3	Move to original next (now prev) Node 2	Node 2	None	1 <- 2 <-> 3 <-> 4 <-> null
4	Swap prev and next of Node 2	Node 2	prev: 1 -> 3, next: 3 -> 1	1 <- 2 <- 3 <-> 4 <-> null
5	Move to original next (now prev) Node 3	Node 3	None	1 <- 2 <- 3 <-> 4 <-> null
6	Swap prev and next of Node 3	Node 3	prev: 2 -> 4, next: 4 -> 2	1 <- 2 <- 3 <- 4 <-> null
7	Move to original next (now prev) Node 4	Node 4	None	1 <- 2 <- 3 <- 4 <-> null
8	Swap prev and next of Node 4	Node 4	prev: 3 -> null, next: null -> 3	1 <- 2 <- 3 <- 4
9	Move to original next (now prev) null	null	None	Traversal ends
10	Update head to last processed node (Node 4)	Node 4	head: Node 1 -> Node 4	4 <-> 3 <-> 2 <-> 1 <-> null

💡 Traversal ends when current node becomes null after processing all nodes.

Variable Tracker

Variable	Start	After Step 2	After Step 4	After Step 6	After Step 8	Final
current	Node 1	Node 2	Node 3	Node 4	null	null
temp	null	null (prev of Node 1)	Node 1 (prev of Node 2)	Node 2 (prev of Node 3)	Node 3 (prev of Node 4)	Node 3
head	Node 1	Node 1	Node 1	Node 1	Node 1	Node 4

Key Moments - 3 Insights

Why do we swap prev and next pointers for each node?

Swapping prev and next reverses the direction of links. See steps 2, 4, 6, and 8 in execution_table where pointers change to point backward instead of forward.

Why do we move current to current.prev after swapping?

After swapping, current.prev points to the original next node. Moving to current.prev lets us continue forward in the original list order. See steps 3, 5, 7, and 9.

How do we update the head after reversal?

The last processed node before current becomes null is the new head. We use temp.prev to find it (step 10).

Visual Quiz - 3 Questions

Look at the execution_table at step 4, what are the prev and next pointers of Node 2?

A prev points to null, next points to Node 3

B prev points to Node 1, next points to Node 3

C prev points to Node 3, next points to Node 1

D prev points to Node 3, next points to null

💡 Hint

Check the 'Pointer Changes' column at step 4 in execution_table.

At which step does the current node become null, ending the traversal?

A Step 9

B Step 8

C Step 7

D Step 10

💡 Hint

Look for the step where 'Current Node' is null in execution_table.

If we forget to update the head after reversal, what would be the state of the list?

A List remains unchanged

B List remains reversed but head points to old first node

C List becomes empty

D List is partially reversed

💡 Hint

Refer to step 10 in execution_table and variable_tracker for head updates.

Concept Snapshot

Reverse a Doubly Linked List:
- Start at head node
- For each node, swap prev and next pointers
- Move to original next node (now prev)
- Repeat until current is null
- Update head to last processed node
- Result: list links reversed direction

Full Transcript

To reverse a doubly linked list, we begin at the head node. For each node, we swap its prev and next pointers to reverse the link directions. We then move to the original next node, which after swapping is accessible via current.prev. We repeat this process until we reach the end of the list (current becomes null). Finally, we update the head pointer to the last processed node, which is the new head of the reversed list. This method ensures the list is reversed in place without creating new nodes.

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