Reverse a Doubly Linked List in DSA C - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of reversing a doubly linked list

What is the printed state of the doubly linked list after reversing it?

DSA C

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

#include <stdio.h>
#include <stdlib.h>

Node* reverse(Node* head) {
    Node* temp = NULL;
    Node* current = head;
    while (current != NULL) {
        temp = current->prev;
        current->prev = current->next;
        current->next = temp;
        current = current->prev;
    }
    if (temp != NULL) {
        head = temp->prev;
    }
    return head;
}

void printList(Node* node) {
    while (node != NULL) {
        printf("%d", node->data);
        if (node->next != NULL) printf(" <-> ");
        node = node->next;
    }
    printf("\n");
}

int main() {
    Node* head = malloc(sizeof(Node));
    Node* second = malloc(sizeof(Node));
    Node* third = malloc(sizeof(Node));

    head->data = 1; head->prev = NULL; head->next = second;
    second->data = 2; second->prev = head; second->next = third;
    third->data = 3; third->prev = second; third->next = NULL;

    head = reverse(head);
    printList(head);
    return 0;
}

A 3 <-> 2 <-> 1

B 1 <-> 2 <-> 3

C 3 -> 2 -> 1

D 1 -> 2 -> 3

💡 Hint

Think about how the prev and next pointers are swapped in each node.

The reverse function swaps the prev and next pointers for each node. After the loop, the head pointer is updated to the last node processed, which becomes the new head. The printed list shows nodes in reverse order with <-> indicating doubly linked connections.

🧠 Conceptual

intermediate

Understanding pointer swaps in reversing a doubly linked list

In the reversal of a doubly linked list, what is the main reason for swapping the prev and next pointers of each node?

A To sort the list in ascending order

B To free the memory of nodes in reverse order

C To reverse the direction of the links so traversal order is reversed

D To duplicate the list nodes

💡 Hint

Think about how links define the order of nodes.

Swapping prev and next pointers reverses the direction of the links between nodes, so the list can be traversed in the opposite order.

🔧 Debug

advanced

Identify the error in this reverse function for doubly linked list

What error will this reverse function cause when reversing a doubly linked list?

DSA C

Node* reverse(Node* head) {
    Node* temp = NULL;
    Node* current = head;
    while (current != NULL) {
        temp = current->next;
        current->next = current->prev;
        current->prev = temp;
        current = current->next;
    }
    if (temp != NULL) {
        head = temp->prev;
    }
    return head;
}

A It will cause an infinite loop

B It will reverse the list correctly

C It will cause a segmentation fault

D It will leave the list unchanged

💡 Hint

Check how current pointer moves after swapping.

The current pointer moves to current->next, but after swapping, current->next points to the previous node, causing the loop to move backward and never reach NULL, resulting in an infinite loop.

❓ Predict Output

advanced

Output after reversing a doubly linked list with 4 nodes

Given a doubly linked list with nodes 10 <-> 20 <-> 30 <-> 40, what is the printed output after applying the reverse function below?

DSA C

Node* reverse(Node* head) {
    Node* temp = NULL;
    Node* current = head;
    while (current != NULL) {
        temp = current->prev;
        current->prev = current->next;
        current->next = temp;
        current = current->prev;
    }
    if (temp != NULL) {
        head = temp->prev;
    }
    return head;
}

// After reversal, printList prints nodes connected by <->

A 10 -> 20 -> 30 -> 40

B 40 <-> 30 <-> 20 <-> 10

C 40 -> 30 -> 20 -> 10

D 10 <-> 20 <-> 30 <-> 40

💡 Hint

The reverse function swaps prev and next pointers for each node.

The reverse function swaps the prev and next pointers for each node, effectively reversing the list order. The printList function prints nodes connected by <->, so the reversed list prints 40 <-> 30 <-> 20 <-> 10.

🧠 Conceptual

expert

Why is updating the head pointer after reversal necessary?

After reversing a doubly linked list by swapping prev and next pointers, why must we update the head pointer to the last processed node?

A Because the list nodes are deleted and recreated

B Because the head pointer always points to NULL after reversal

C Because the head pointer must point to the middle node after reversal

D Because the original head becomes the tail and the new head is the last node processed

💡 Hint

Think about the position of the head before and after reversal.

The original head node becomes the tail after reversal. The new head is the last node processed in the loop, so we must update the head pointer to point to it to correctly represent the reversed list.