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).

Practice

1. What happens to the tail pointer when you delete the last node from a doubly linked list?

easy

A. It becomes NULL immediately without checking.

B. It remains unchanged.

C. It points to the head node.

D. It moves to the previous node of the deleted node.

Solution

1. Step 1: Understand the tail pointer role

   The tail pointer always points to the last node in the doubly linked list.

2. Step 2: Update tail after deletion

   When the last node is deleted, the tail pointer must move to the previous node to keep pointing to the new last node.

3. Final Answer:

   It moves to the previous node of the deleted node. -> Option D

4. Quick Check:

   Tail points to previous node after deletion [OK]

Hint: Tail always points to last node; update to previous on delete [OK]

Common Mistakes:

• Setting tail to NULL without checking if list is empty
• Not updating tail pointer after deletion
• Pointing tail to head incorrectly

2. Which of the following is the correct syntax to delete the last node in a doubly linked list in C?

easy

A. tail = tail->prev; free(tail->next); tail->next = NULL;

B. free(tail); tail = tail->prev; tail->next = NULL;

C. tail->prev = tail; free(tail); tail = NULL;

D. tail->next = NULL; free(tail); tail = tail->prev;

Solution

1. Step 1: Free the last node correctly

   We first move tail to previous node, then free the old last node which is tail->next.

2. Step 2: Update tail's next pointer

   After freeing, set tail->next to NULL to mark new end of list.

3. Final Answer:

   tail = tail->prev; free(tail->next); tail->next = NULL; -> Option A

4. Quick Check:

   Move tail first, free old node, update next pointer [OK]

Hint: Move tail first, then free old node, update next pointer [OK]

Common Mistakes:

• Freeing tail before moving pointer
• Not setting tail->next to NULL
• Incorrect pointer assignments causing memory errors

3. What will be the output of the following code snippet after deleting the last node?

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

Node* tail = NULL;
// List: 10 <-> 20 <-> 30
// tail points to node with data 30

// Delete last node
Node* temp = tail;
tail = tail->prev;
free(temp);
tail->next = NULL;

// Print list from head
Node* head = tail;
while(head->prev) head = head->prev;
while(head) {
  printf("%d ", head->data);
  head = head->next;
}

medium

A. 10 20

B. 10 20 30

C. 20 30

D. 10 30

Solution

1. Step 1: Understand list before deletion

   Initial list is 10 <-> 20 <-> 30, tail points to 30.

2. Step 2: Delete last node and update pointers

   Last node 30 is freed, tail moves to 20, tail->next set to NULL.

3. Step 3: Print list from head

   Head is found by moving to start (10), printing nodes 10 and 20.

4. Final Answer:

   10 20 -> Option A

5. Quick Check:

   Last node removed, list prints 10 20 [OK]

Hint: After deletion, tail moves back; print from head to see updated list [OK]

Common Mistakes:

• Printing old tail node after deletion
• Not updating tail->next to NULL
• Starting print from tail instead of head

4. Identify the error in the following code snippet that deletes the last node of a doubly linked list:

void deleteEnd(Node** tail) {
  if (*tail == NULL) return;
  Node* temp = *tail;
  *tail = (*tail)->prev;
  free(temp);
  (*tail)->next = NULL;
}

medium

A. Not freeing the node properly.

B. Dereferencing tail without checking if list becomes empty.

C. Not updating the head pointer.

D. Using double pointer for tail unnecessarily.

Solution

1. Step 1: Check for empty list after deletion

   If the list had only one node, after deletion tail becomes NULL, so (*tail)->next causes error.

2. Step 2: Fix by checking tail before dereference

   Must check if *tail is not NULL before setting (*tail)->next = NULL.

3. Final Answer:

   Dereferencing tail without checking if list becomes empty. -> Option B

4. Quick Check:

   Check tail NULL before accessing next pointer [OK]

Hint: Always check if tail is NULL before accessing its members [OK]

Common Mistakes:

• Dereferencing NULL pointer after deletion
• Ignoring empty list edge case
• Not freeing memory causing leaks

5. You have a doubly linked list with nodes: 5 <-> 15 <-> 25 <-> 35. After deleting the last node twice, what will be the printed list from head?

// Initial tail points to 35
// Delete last node twice
Node* temp;
temp = tail;
tail = tail->prev;
free(temp);
tail->next = NULL;

temp = tail;
tail = tail->prev;
free(temp);
tail->next = NULL;

// Print from head
Node* head = tail;
while(head->prev) head = head->prev;
while(head) {
  printf("%d ", head->data);
  head = head->next;
}

hard

A. 5 15 25

B. 15 25

C. 5 15

D. 25 35

Solution

1. Step 1: Understand initial list and tail

   List is 5 <-> 15 <-> 25 <-> 35, tail points to 35.

2. Step 2: Delete last node once

   Delete 35, tail moves to 25, tail->next = NULL.

3. Step 3: Delete last node second time

   Delete 25, tail moves to 15, tail->next = NULL.

4. Step 4: Print list from head

   Head found by moving to start (5), print nodes 5 and 15.

5. Final Answer:

   5 15 -> Option C

6. Quick Check:

   Two deletions remove last two nodes, list prints 5 15 [OK]

Hint: Each delete moves tail back; print from head to see current list [OK]

Common Mistakes:

• Not updating tail->next to NULL after each deletion
• Printing from tail instead of head
• Assuming deleted nodes still exist