Delete from End of Doubly Linked List in DSA C - Build from Scratch

Delete from End of Doubly Linked List

📖 Scenario: You are managing a playlist of songs using a doubly linked list. Each node contains a song number. You want to remove the last song from the playlist.

🎯 Goal: Build a doubly linked list with 3 nodes, then delete the last node, and finally print the updated list.

📋 What You'll Learn

Create a doubly linked list with exactly 3 nodes containing data 10, 20, and 30

Create a pointer called head pointing to the first node

Create a pointer called tail pointing to the last node

Write a function called deleteFromEnd that deletes the last node from the list

Print the list from head to tail after deletion

💡 Why This Matters

🌍 Real World

Doubly linked lists are used in music players, browsers, and undo-redo features where you need to move forward and backward easily.

💼 Career

Understanding linked list operations is fundamental for software developers working with data structures, memory management, and system programming.

1

Create the doubly linked list with 3 nodes

Create a struct called Node with int data, Node *prev, and Node *next. Then create 3 nodes with data 10, 20, and 30. Link them so that head points to the first node and tail points to the last node.

DSA C

// Define struct Node and create 3 linked nodes
// Your code here

Hint

Remember to link each node's next and prev pointers correctly.

2

Create the deleteFromEnd function

Create a function called deleteFromEnd that takes Node **head and Node **tail as parameters. It should delete the last node from the doubly linked list and update tail accordingly.

DSA C

#include 
#include 

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

void deleteFromEnd(Node **head, Node **tail) {
    // Your code here
}

int main() {
    Node *head = (Node *)malloc(sizeof(Node));
    Node *second = (Node *)malloc(sizeof(Node));
    Node *tail = (Node *)malloc(sizeof(Node));

    head->data = 10;
    head->prev = NULL;
    head->next = second;

    second->data = 20;
    second->prev = head;
    second->next = tail;

    tail->data = 30;
    tail->prev = second;
    tail->next = NULL;

    // Your code here

    return 0;
}

Hint

Check if the list is empty or has only one node before deleting.

3

Traverse and print the list from head to tail

Create a Node * pointer called current and set it to head. Use a while loop to traverse the list and print each node's data followed by ->. After the loop, print NULL.

DSA C

#include 
#include 

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

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

int main() {
    Node *head = (Node *)malloc(sizeof(Node));
    Node *second = (Node *)malloc(sizeof(Node));
    Node *tail = (Node *)malloc(sizeof(Node));

    head->data = 10;
    head->prev = NULL;
    head->next = second;

    second->data = 20;
    second->prev = head;
    second->next = tail;

    tail->data = 30;
    tail->prev = second;
    tail->next = NULL;

    deleteFromEnd(&head, &tail);

    Node *current = head;
    // Your code here

    return 0;
}

Hint

Use a while loop to move through the list until current is NULL.

4

Print the updated list after deletion

Run the program and observe the printed output. It should show the list after deleting the last node. The output should be: 10 -> 20 -> NULL

DSA C

#include 
#include 

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

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

int main() {
    Node *head = (Node *)malloc(sizeof(Node));
    Node *second = (Node *)malloc(sizeof(Node));
    Node *tail = (Node *)malloc(sizeof(Node));

    head->data = 10;
    head->prev = NULL;
    head->next = second;

    second->data = 20;
    second->prev = head;
    second->next = tail;

    tail->data = 30;
    tail->prev = second;
    tail->next = NULL;

    deleteFromEnd(&head, &tail);

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

    // Your code here

    return 0;
}

Hint

Run the program to see the updated list after deleting the last node.