Delete from End of Doubly Linked List in DSA C - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output after deleting last node from doubly linked list

What is the printed state of the doubly linked list after deleting the last node?

DSA C

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

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

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

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

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 = deleteFromEnd(head);
    printList(head);
    return 0;
}

A 1 <-> 2 <-> 3 <-> NULL

B 1 <-> 2 <-> NULL

C 1 <-> NULL

D NULL

💡 Hint

Think about what happens to the last node and the second last node's next pointer.

The function deletes the last node (3). The second last node (2) now points to NULL, so the list is 1 <-> 2 <-> NULL.

🧠 Conceptual

intermediate

Effect of deleting from an empty doubly linked list

What is the result of calling the deleteFromEnd function on an empty doubly linked list (head is NULL)?

DSA C

Node* deleteFromEnd(Node* head) {
    if (head == NULL) return NULL;
    // rest of code omitted
}

A Returns NULL without any error

B Deletes a random node

C Causes a segmentation fault

D Returns the original head pointer

💡 Hint

Check the first condition in the function.

If the list is empty (head is NULL), the function returns NULL immediately without errors.

🔧 Debug

advanced

Identify the bug in deleteFromEnd function

What is the bug in this deleteFromEnd function for doubly linked list?

DSA C

Node* deleteFromEnd(Node* head) {
    if (head == NULL) return NULL;
    if (head->next == NULL) {
        free(head);
        return NULL;
    }
    Node* temp = head;
    while (temp->next != NULL) {
        temp = temp->next;
    }
    temp->next = NULL;
    free(temp);
    return head;
}

A Missing free(head) when list has one node

B No bug, code is correct

C Should update head pointer after deletion

D temp->next = NULL; should be temp->prev->next = NULL;

💡 Hint

Check how the previous node's next pointer is updated before freeing the last node.

The code sets temp->next = NULL, but temp->next is already NULL (last node). It should set temp->prev->next = NULL to unlink the last node.

❓ Predict Output

advanced

Output after deleting last node from single-node doubly linked list

What is the printed state of the doubly linked list after deleting the last node when the list has only one node?

DSA C

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

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

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

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

int main() {
    Node* head = malloc(sizeof(Node));
    head->data = 10; head->prev = NULL; head->next = NULL;

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

A 10

B 10 <-> NULL

C NULL

D Segmentation fault

💡 Hint

Deleting the only node should leave the list empty.

The function frees the only node and returns NULL, so printing the list shows NULL.

🧠 Conceptual

expert

Time complexity of deleting from end in doubly linked list without tail pointer

What is the time complexity of deleting the last node from a doubly linked list if you do NOT maintain a tail pointer?

A O(n), because you must traverse to the last node

B O(1), because you can access the last node directly

C O(log n), because of binary search on nodes

D O(n^2), because of nested traversal

💡 Hint

Without a tail pointer, you must start from head and move forward to find the last node.

Without a tail pointer, you traverse the list from head to last node, which takes linear time O(n).