Reverse a Doubly Linked List in DSA C - Execution Trace

Concept Flow - Reverse a Doubly Linked List

Start at head node

↓

For each node: Swap prev and next pointers

↓

Move to new prev (old next) node

↓

Repeat until current node is NULL

↓

Update head to last processed node

↓

Done: List reversed

We start at the head node, swap the prev and next pointers of each node, move forward using the swapped pointers, and finally update the head to the last node processed.

Execution Sample

DSA C

void reverse(struct Node** head_ref) {
  struct Node* current = *head_ref;
  struct Node* temp = NULL;
  while (current != NULL) {
    temp = current->prev;
    current->prev = current->next;
    current->next = temp;
    current = current->prev;
  }
  if (temp != NULL) *head_ref = temp->prev;
}

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

Execution Table

Step	Operation	Current Node	prev Pointer Before	next Pointer Before	prev Pointer After	next Pointer After	Move To	Head Pointer	Visual State
1	Start at head	Node 1	NULL	Node 2	Node 2	NULL	Node 2	Node 1	1 <-> 2 <-> 3 <-> 4 <-> NULL
2	Swap pointers	Node 2	Node 1	Node 3	Node 3	Node 1	Node 3	Node 1	1 <-> 2 <-> 3 <-> 4 <-> NULL
3	Swap pointers	Node 3	Node 2	Node 4	Node 4	Node 2	Node 4	Node 1	1 <-> 2 <-> 3 <-> 4 <-> NULL
4	Swap pointers	Node 4	Node 3	NULL	NULL	Node 3	NULL	Node 1	1 <-> 2 <-> 3 <-> 4 <-> NULL
5	Update head	NULL	-	-	-	-	-	Node 4	4 <-> 3 <-> 2 <-> 1 <-> NULL
6	End	NULL	-	-	-	-	-	Node 4	4 <-> 3 <-> 2 <-> 1 <-> NULL

💡 current becomes NULL, loop ends, head updated to last processed node (Node 4)

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 4	After Step 5	Final
current	Node 1	Node 2	Node 3	Node 4	NULL	NULL	NULL
temp	NULL	Node 1	Node 2	Node 3	Node 4	Node 4	Node 4
head_ref	Node 1	Node 1	Node 1	Node 1	Node 1	Node 4	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 the list links. See execution_table steps 1 to 4 where prev and next pointers are exchanged.

Why do we move current to current->prev after swapping?

After swapping, current->prev points to the next node in original order. Moving to current->prev continues traversal forward. This is shown in execution_table column 'Move To'.

How do we update the head pointer after reversal?

After the loop ends, temp points to the old prev of the last node processed. The new head is temp->prev, as shown in execution_table step 5.

Visual Quiz - 3 Questions

Look at the execution_table at step 3, what is the 'prev Pointer After' of Node 3?

A Node 2

B Node 1

C Node 4

D NULL

💡 Hint

Check the 'prev Pointer After' column for step 3 in execution_table.

At which step does the current pointer become NULL, ending the loop?

A Step 4

B Step 5

C Step 6

D Step 3

💡 Hint

Look at the 'current Node' column in execution_table to find when it becomes NULL.

If we forget to update the head pointer after reversal, what will be the head node?

A Node 4 (new head)

B Node 1 (original head)

C NULL

D Node 2

💡 Hint

Refer to variable_tracker for head_ref changes and execution_table step 5.

Concept Snapshot

Reverse a Doubly Linked List:
- Traverse each node from head
- Swap prev and next pointers
- Move to original next via swapped pointers
- Update head to last node processed
- Result: list links reversed direction

Full Transcript

To reverse a doubly linked list, we start at the head node and for each node, swap its prev and next pointers. This reverses the direction of the links. We then move to the next node using the swapped pointers (current = current->prev). When current becomes NULL, we update the head pointer to the last node processed, which is stored in temp->prev. This process reverses the list so the last node becomes the new head. The execution table shows each step with pointer changes and the visual state of the list. The variable tracker shows how current, temp, and head_ref change during execution. Key moments clarify why we swap pointers, how traversal continues, and how the head is updated. The visual quiz tests understanding of pointer changes and loop termination.

Practice

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

easy

A. To convert it into a singly linked list

B. To delete all nodes from the list

C. To make the last node the first and the first node the last

D. To sort the list in ascending order

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.

2. Step 2: Define reversing operation

   Reversing means swapping the direction so the last node becomes the first and vice versa.

3. Final Answer:

   To make the last node the first and the first node the last -> Option C

4. Quick Check:

   Reverse = last becomes first [OK]

Hint: Reversing flips start and end nodes [OK]

Common Mistakes:

• Thinking reversing deletes nodes
• Confusing reversing with sorting
• Assuming it changes list type

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

easy

A. temp = node->prev; node->prev = node->next; node->next = node->next;

B. node->next = node->prev; node->prev = node->next;

C. node->prev = node->next; node->next = node->prev;

D. temp = node->next; node->next = node->prev; node->prev = temp;

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 to node->prev, then node->prev to temp.

3. Final Answer:

   temp = node->next; node->next = node->prev; node->prev = temp; -> Option D

4. Quick Check:

   Swap pointers using temp variable [OK]

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

Common Mistakes:

• Swapping without temp loses pointer data
• Assigning both pointers to same value
• Mixing order of assignments

3. Given the following doubly linked list nodes and code snippet, what will be the new head node's data after reversal?

struct Node {
  int data;
  struct Node* next;
  struct Node* prev;
};

// List: 1 <-> 2 <-> 3 <-> NULL
struct Node* head = node1; // node1->data = 1

// Reversal code snippet:
struct Node* current = head;
struct 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;
}

medium

A. 1

B. 3

C. 2

D. NULL

Solution

1. Step 1: Trace pointer swaps in the loop

   Each node swaps its next and prev pointers, moving current backward through original list.

2. Step 2: Update head after loop

   After loop, head is set to temp->prev, which points to original last node (data 3).

3. Final Answer:

   3 -> Option B

4. Quick Check:

   New head = original tail = 3 [OK]

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

Common Mistakes:

• Not updating head pointer after reversal
• Confusing prev and next pointers
• Assuming head remains same

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

void reverse(struct Node** head_ref) {
  struct Node* current = *head_ref;
  struct Node* temp = NULL;
  while (current != NULL) {
    temp = current->next;
    current->next = current->prev;
    current->prev = temp;
    current = current->prev;
  }
  if (temp != NULL) {
    *head_ref = temp->prev;
  }
}

medium

A. temp should store current->prev instead of current->next

B. current should move to current->next instead of current->prev

C. The head pointer update is incorrect

D. No error, code is correct

Solution

1. Step 1: Verify pointer swaps

   The next/prev swaps correctly reverse directions as current traverses the original next chain (now in prev).

2. Step 2: Analyze temp assignment

   Temp should store current->prev before swapping, not current->next, to avoid losing pointer.

3. Final Answer:

   temp should store current->prev instead of current->next -> Option A

4. Quick Check:

   Correct temp assignment preserves traversal [OK]

Hint: Temp must hold current->prev before swapping pointers [OK]

Common Mistakes:

• Incorrect head pointer update logic
• Moving current incorrectly after swap
• Not updating head pointer properly

5. You have a doubly linked list with nodes containing integer data. After reversing the list using the standard pointer swap method, which of the following statements is TRUE about the list's traversal?

hard

A. Traversing from the new head using next pointers visits nodes in original reverse order

B. Traversing from the new head using prev pointers visits nodes in original order

C. Traversing from the original head using next pointers visits nodes in reversed order

D. Traversing from the new head using next pointers visits nodes in original order

Solution

1. Step 1: Understand reversal effect on pointers

   Reversing swaps next and prev pointers, so next pointers now point backward in original list.

2. Step 2: Analyze traversal from new head

   Starting at new head, following next pointers visits nodes in original reverse order.

3. Final Answer:

   Traversing from the new head using next pointers visits nodes in original reverse order -> Option A

4. Quick Check:

   Next pointers after reverse = original prev [OK]

Hint: Next pointers after reverse follow original prev links [OK]

Common Mistakes:

• Assuming next pointers still go forward after reverse
• Confusing traversal directions
• Thinking original head remains start