Create and Initialize Doubly Linked List in DSA C - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Doubly Linked List Initialization

What is the printed state of the doubly linked list after running the following code?

DSA C

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

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

Node* createNode(int data) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->data = data;
    newNode->prev = NULL;
    newNode->next = NULL;
    return newNode;
}

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

int main() {
    Node* head = createNode(10);
    Node* second = createNode(20);
    Node* third = createNode(30);

    head->next = second;
    second->prev = head;
    second->next = third;
    third->prev = second;

    printList(head);
    return 0;
}

A 30 <-> 20 <-> 10 -> NULL

B 10 -> 20 -> 30 -> NULL

C 10 <-> 20 -> 30 -> NULL

D 10 <-> 20 <-> 30 -> NULL

💡 Hint

Check how the next and prev pointers are linked between nodes.

The code creates three nodes with values 10, 20, and 30. It links them in order with proper prev and next pointers, so the list prints as 10 <-> 20 <-> 30 -> NULL.

❓ Predict Output

intermediate

State of Doubly Linked List After Adding a Node at Head

What is the printed state of the doubly linked list after adding a new node with value 5 at the head?

DSA C

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

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

Node* createNode(int data) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->data = data;
    newNode->prev = NULL;
    newNode->next = NULL;
    return newNode;
}

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

int main() {
    Node* head = createNode(10);
    Node* second = createNode(20);
    head->next = second;
    second->prev = head;

    Node* newHead = createNode(5);
    newHead->next = head;
    head->prev = newHead;
    head = newHead;

    printList(head);
    return 0;
}

A 5 <-> 10 <-> 20 -> NULL

B 10 <-> 20 <-> 5 -> NULL

C 5 -> 10 -> 20 -> NULL

D 20 <-> 10 <-> 5 -> NULL

💡 Hint

Remember to update both prev and next pointers when adding at head.

The new node with value 5 is added before the current head (10). The prev pointer of old head points to new node, and new node's next points to old head. So the list is 5 <-> 10 <-> 20 -> NULL.

🔧 Debug

advanced

Identify the Bug in Doubly Linked List Node Creation

What error will occur when running this code to create a doubly linked list node?

DSA C

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

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

Node* createNode(int data) {
    Node* newNode = malloc(sizeof(Node));
    newNode->data = data;
    newNode->prev = NULL;
    newNode->next = NULL;
    return newNode;
}

int main() {
    Node* node = createNode(10);
    printf("%d\n", node->data);
    free(node);
    return 0;
}

A No error, prints 10

B Compilation error: missing cast in malloc

C Runtime error: segmentation fault

D Compilation error: missing #include <stdlib.h>

💡 Hint

Casting malloc is optional in C, and stdlib.h is included.

The code correctly allocates memory and initializes the node. Casting malloc is optional in C and stdlib.h is included, so it prints 10 without errors.

❓ Predict Output

advanced

Output After Removing a Node from Doubly Linked List

What is the printed state of the doubly linked list after removing the middle node (20) from the list?

DSA C

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

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

Node* createNode(int data) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->data = data;
    newNode->prev = NULL;
    newNode->next = NULL;
    return newNode;
}

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

int main() {
    Node* head = createNode(10);
    Node* second = createNode(20);
    Node* third = createNode(30);

    head->next = second;
    second->prev = head;
    second->next = third;
    third->prev = second;

    // Remove second node
    head->next = third;
    third->prev = head;
    free(second);

    printList(head);
    return 0;
}

A 20 <-> 30 -> NULL

B 10 -> 30 -> NULL

C 10 <-> 30 -> NULL

D 10 <-> 20 <-> 30 -> NULL

💡 Hint

Check how the prev and next pointers are updated after removal.

The node with value 20 is removed by linking 10 directly to 30 and updating pointers accordingly. So the list prints as 10 <-> 30 -> NULL.

🧠 Conceptual

expert

Memory Management in Doubly Linked List Initialization

Which statement about memory management when creating and initializing a doubly linked list in C is TRUE?

A Using malloc for nodes is optional because the compiler manages memory automatically.

B Each node must be allocated with malloc and freed when no longer needed to avoid memory leaks.

C Freeing the head node automatically frees all other nodes linked to it.

D Nodes can be created as local variables inside functions without malloc to persist after function returns.

💡 Hint

Think about how dynamic memory works in C and what happens if you don't free allocated memory.

In C, nodes must be dynamically allocated with malloc to persist beyond function scope, and each allocated node must be freed manually to avoid memory leaks. Local variables do not persist after function returns, and freeing one node does not free others linked to it.