Delete by Value in Doubly Linked List in DSA C - Build from Scratch

Delete by Value in Doubly Linked List

📖 Scenario: You are managing a playlist of songs using a doubly linked list. Each node contains a song's unique ID. You want to remove a song by its ID from the playlist.

🎯 Goal: Build a C program that creates a doubly linked list with given song IDs, sets a target song ID to delete, deletes the node with that song ID from the list, and prints the updated playlist.

📋 What You'll Learn

Create a doubly linked list with nodes containing these exact song IDs in order: 101, 202, 303, 404, 505

Create an integer variable called target and set it to 303

Write a function deleteByValue that deletes the node with the value equal to target from the doubly linked list

Print the updated doubly linked list after deletion in the format: 101 <-> 202 <-> 404 <-> 505

💡 Why This Matters

🌍 Real World

Doubly linked lists are used in music players, browsers, and other apps to manage ordered data with easy forward and backward navigation.

💼 Career

Understanding linked list operations like deletion is fundamental for software developers working with low-level data structures, memory management, and performance-critical applications.

1

Create the doubly linked list with given song IDs

Create a doubly linked list with nodes containing these exact song IDs in order: 101, 202, 303, 404, 505. Use the struct Node with int data, Node* prev, and Node* next. Create a pointer head pointing to the first node.

DSA C

#include 
#include 

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

int main() {
    struct Node* head = NULL;

    // Create nodes with data 101, 202, 303, 404, 505 and link them
    // Your code here

    return 0;
}

Hint

Use malloc to create each node. Link nodes by setting next and prev pointers carefully.

2

Set the target song ID to delete

Create an integer variable called target and set it to 303.

DSA C

#include 
#include 

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

int main() {
    struct Node* head = NULL;
    struct Node* second = NULL;
    struct Node* third = NULL;
    struct Node* fourth = NULL;
    struct Node* fifth = NULL;

    head = (struct Node*)malloc(sizeof(struct Node));
    second = (struct Node*)malloc(sizeof(struct Node));
    third = (struct Node*)malloc(sizeof(struct Node));
    fourth = (struct Node*)malloc(sizeof(struct Node));
    fifth = (struct Node*)malloc(sizeof(struct Node));

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

    second->data = 202;
    second->prev = head;
    second->next = third;

    third->data = 303;
    third->prev = second;
    third->next = fourth;

    fourth->data = 404;
    fourth->prev = third;
    fourth->next = fifth;

    fifth->data = 505;
    fifth->prev = fourth;
    fifth->next = NULL;

    // Create an integer variable target and set it to 303
    // Your code here

    return 0;
}

Hint

Declare int target = 303; inside main.

3

Write the function to delete a node by value

Write a function called deleteByValue that takes a pointer to the head pointer (struct Node** head) and an integer value. It deletes the first node in the doubly linked list whose data equals value. Update the links properly and free the deleted node's memory. If the node to delete is the head, update the head pointer.

DSA C

#include 
#include 

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

void deleteByValue(struct Node** head, int value) {
    // Implement deletion of node with data == value
    // Your code here
}

int main() {
    struct Node* head = NULL;
    struct Node* second = NULL;
    struct Node* third = NULL;
    struct Node* fourth = NULL;
    struct Node* fifth = NULL;

    head = (struct Node*)malloc(sizeof(struct Node));
    second = (struct Node*)malloc(sizeof(struct Node));
    third = (struct Node*)malloc(sizeof(struct Node));
    fourth = (struct Node*)malloc(sizeof(struct Node));
    fifth = (struct Node*)malloc(sizeof(struct Node));

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

    second->data = 202;
    second->prev = head;
    second->next = third;

    third->data = 303;
    third->prev = second;
    third->next = fourth;

    fourth->data = 404;
    fourth->prev = third;
    fourth->next = fifth;

    fifth->data = 505;
    fifth->prev = fourth;
    fifth->next = NULL;

    int target = 303;

    // Call deleteByValue here
    // Your code here

    return 0;
}

Hint

Traverse the list to find the node with data == value. Fix links of previous and next nodes. If deleting head, update *head. Free the node.

4

Print the updated doubly linked list

Write a loop to print the updated doubly linked list starting from head. Print each node's data separated by <-> . End with a newline. The output should be: 101 <-> 202 <-> 404 <-> 505

DSA C

#include 
#include 

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

void deleteByValue(struct Node** head, int value) {
    struct Node* current = *head;

    while (current != NULL) {
        if (current->data == value) {
            if (current->prev != NULL) {
                current->prev->next = current->next;
            } else {
                *head = current->next;
            }
            if (current->next != NULL) {
                current->next->prev = current->prev;
            }
            free(current);
            return;
        }
        current = current->next;
    }
}

int main() {
    struct Node* head = NULL;
    struct Node* second = NULL;
    struct Node* third = NULL;
    struct Node* fourth = NULL;
    struct Node* fifth = NULL;

    head = (struct Node*)malloc(sizeof(struct Node));
    second = (struct Node*)malloc(sizeof(struct Node));
    third = (struct Node*)malloc(sizeof(struct Node));
    fourth = (struct Node*)malloc(sizeof(struct Node));
    fifth = (struct Node*)malloc(sizeof(struct Node));

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

    second->data = 202;
    second->prev = head;
    second->next = third;

    third->data = 303;
    third->prev = second;
    third->next = fourth;

    fourth->data = 404;
    fourth->prev = third;
    fourth->next = fifth;

    fifth->data = 505;
    fifth->prev = fourth;
    fifth->next = NULL;

    int target = 303;

    deleteByValue(&head, target);

    // Print the updated list
    // Your code here

    return 0;
}

Hint

Use a while loop to traverse from head. Print each node's data. Print <-> between nodes except after the last one.