Insert at End of Doubly Linked List in DSA C - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output after inserting nodes at the end

What is the printed state of the doubly linked list after inserting 10, 20, and 30 at the end?

DSA C

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

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

Node* insertAtEnd(Node* head, int data) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->data = data;
    newNode->next = NULL;
    if (head == NULL) {
        newNode->prev = NULL;
        return newNode;
    }
    Node* temp = head;
    while (temp->next != NULL) {
        temp = temp->next;
    }
    temp->next = newNode;
    newNode->prev = temp;
    return head;
}

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

int main() {
    Node* head = NULL;
    head = insertAtEnd(head, 10);
    head = insertAtEnd(head, 20);
    head = insertAtEnd(head, 30);
    printList(head);
    return 0;
}

A 10 -> 20 -> null

B 30 -> 20 -> 10 -> null

C 10 -> 20 -> 30 -> null

D null

💡 Hint

Remember that inserting at the end adds the new node after the last node.

The insertAtEnd function adds nodes at the end, so the list grows as 10, then 10->20, then 10->20->30. The printList function prints nodes from head to tail.

❓ Predict Output

intermediate

Output after inserting into an empty list

What is the printed state of the doubly linked list after inserting a single node with value 5 into an empty list?

DSA C

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

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

Node* insertAtEnd(Node* head, int data) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->data = data;
    newNode->next = NULL;
    if (head == NULL) {
        newNode->prev = NULL;
        return newNode;
    }
    Node* temp = head;
    while (temp->next != NULL) {
        temp = temp->next;
    }
    temp->next = newNode;
    newNode->prev = temp;
    return head;
}

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

int main() {
    Node* head = NULL;
    head = insertAtEnd(head, 5);
    printList(head);
    return 0;
}

A 5 -> null

B null

C 5 -> 5 -> null

D 0 -> 5 -> null

💡 Hint

Inserting into an empty list creates a single node which is both head and tail.

Since the list is empty, the new node becomes the head with no previous or next nodes. The print shows the single node followed by null.

🔧 Debug

advanced

Identify the bug causing a segmentation fault

Why does the following insertAtEnd function cause a segmentation fault when inserting into a non-empty list?

DSA C

Node* insertAtEnd(Node* head, int data) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->data = data;
    newNode->next = NULL;
    if (head == NULL) {
        newNode->prev = NULL;
        return newNode;
    }
    Node* temp = head;
    while (temp->next != NULL) {
        temp = temp->next;
    }
    temp->next = newNode;
    // Missing assignment here
    return head;
}

A newNode->prev is not set, so accessing prev causes segmentation fault

B newNode->next is not set to NULL, causing infinite loop

C head is NULL but function does not handle it

D malloc is not called, so newNode is NULL

💡 Hint

Check if all pointers of the new node are properly assigned.

The function forgets to set newNode->prev = temp. Without this, the prev pointer is uninitialized and can cause a segmentation fault when accessed.

❓ Predict Output

advanced

Output after multiple insertions and one deletion

Given the code below, what is the printed list after inserting 1, 2, 3 at the end and then deleting the node with value 2?

DSA C

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

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

Node* insertAtEnd(Node* head, int data) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->data = data;
    newNode->next = NULL;
    if (head == NULL) {
        newNode->prev = NULL;
        return newNode;
    }
    Node* temp = head;
    while (temp->next != NULL) {
        temp = temp->next;
    }
    temp->next = newNode;
    newNode->prev = temp;
    return head;
}

Node* deleteNode(Node* head, int key) {
    Node* temp = head;
    while (temp != NULL && temp->data != key) {
        temp = temp->next;
    }
    if (temp == NULL) return head;
    if (temp->prev != NULL) temp->prev->next = temp->next;
    else head = temp->next;
    if (temp->next != NULL) temp->next->prev = temp->prev;
    free(temp);
    return head;
}

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

int main() {
    Node* head = NULL;
    head = insertAtEnd(head, 1);
    head = insertAtEnd(head, 2);
    head = insertAtEnd(head, 3);
    head = deleteNode(head, 2);
    printList(head);
    return 0;
}

A 1 -> 2 -> 3 -> null

B 1 -> 3 -> null

C 2 -> 3 -> null

D 1 -> null

💡 Hint

Deleting node with value 2 removes it from the list, linking 1 directly to 3.

The deleteNode function removes the node with data 2 and correctly updates the previous and next pointers, resulting in the list 1 -> 3 -> null.

🧠 Conceptual

expert

Why is updating the prev pointer important in doubly linked list insertion?

In the insertAtEnd function for a doubly linked list, why must we update the new node's prev pointer to point to the last node?

A To avoid memory leaks during insertion

B To prevent the list from becoming circular

C To ensure the new node becomes the head of the list

D To maintain backward traversal capability of the list

💡 Hint

Think about how doubly linked lists allow moving backwards.

The prev pointer allows moving backward through the list. Without setting it, backward traversal breaks, causing incorrect behavior.