Delete Node at End in DSA C - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output after deleting the last node?

Given the linked list and the delete at end function, what will be the printed list after deletion?

DSA C

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

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

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

int main() {
    struct Node* head = malloc(sizeof(struct Node));
    head->data = 1;
    head->next = malloc(sizeof(struct Node));
    head->next->data = 2;
    head->next->next = malloc(sizeof(struct Node));
    head->next->next->data = 3;
    head->next->next->next = NULL;

    deleteAtEnd(&head);
    printList(head);
    return 0;
}

A 1 -> 2 -> null

B 1 -> 2 -> 3 -> null

C 1 -> null

D null

💡 Hint

Think about which node is removed when deleting at the end.

The function deletes the last node (which has data 3). So the list becomes 1 -> 2 -> null.

❓ Predict Output

intermediate

What happens if the list has only one node and we delete at end?

Consider a linked list with a single node containing 5. After calling deleteAtEnd, what is the output of printList?

DSA C

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

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

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

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

    deleteAtEnd(&head);
    printList(head);
    return 0;
}

A 5 -> null

B null

C Segmentation fault

D 5

💡 Hint

Deleting the only node should leave the list empty.

The only node is freed and head is set to NULL, so printList prints null.

🔧 Debug

advanced

Why does this deleteAtEnd function cause a crash?

Identify the problem in this deleteAtEnd function that causes a crash when deleting the last node in a list with two nodes.

DSA C

void deleteAtEnd(struct Node** head) {
    struct Node* temp = *head;
    while (temp->next != NULL) {
        temp = temp->next;
    }
    free(temp);
    temp = NULL;
}

A The loop goes to the last node, but we never update the previous node's next pointer to NULL.

B The function frees the head pointer instead of the last node.

C The function does not check if the list is empty before deleting.

D The function frees the second last node instead of the last node.

💡 Hint

Think about what happens to the node before the last node after deletion.

The function frees the last node but does not update the previous node's next pointer, so it still points to freed memory causing a crash.

🧠 Conceptual

advanced

What is the time complexity of deleting the last node in a singly linked list?

Given a singly linked list with n nodes, what is the time complexity of deleting the last node?

A O(n^2)

B O(1)

C O(log n)

D O(n)

💡 Hint

You need to find the second last node before deleting the last node.

Since singly linked lists do not have backward pointers, you must traverse from the head to find the second last node, which takes O(n) time.

🚀 Application

expert

After multiple deletions at end, what is the final list?

Starting with the list 10 -> 20 -> 30 -> 40 -> null, we call deleteAtEnd three times. What is the final printed list?

DSA C

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

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

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

int main() {
    struct Node* head = malloc(sizeof(struct Node));
    head->data = 10;
    head->next = malloc(sizeof(struct Node));
    head->next->data = 20;
    head->next->next = malloc(sizeof(struct Node));
    head->next->next->data = 30;
    head->next->next->next = malloc(sizeof(struct Node));
    head->next->next->next->data = 40;
    head->next->next->next->next = NULL;

    deleteAtEnd(&head);
    deleteAtEnd(&head);
    deleteAtEnd(&head);
    printList(head);
    return 0;
}

A 10 -> 20 -> null

B null

C 10 -> null

D 20 -> null

💡 Hint

Each deletion removes the last node, so track the list after each call.

After first deletion: 10 -> 20 -> 30 -> null After second deletion: 10 -> 20 -> null After third deletion: 10 -> null