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.

Practice

1. What happens when you delete a node by value in a doubly linked list?

easy

A. Only the first node is deleted without checking value

B. The node with the matching value is removed and links are updated

C. All nodes are deleted regardless of value

D. The list is reversed instead of deleting

Solution

1. Step 1: Locate the node with the given value

   Traverse the list from head to tail to find the node whose data matches the value to delete.

2. Step 2: Update links to remove the node

   Adjust the previous node's next pointer and the next node's previous pointer to bypass the node to be deleted.

3. Final Answer:

   The node with the matching value is removed and links are updated -> Option B

4. Quick Check:

   Deleting by value removes matching node [OK]

Hint: Find node by value, then fix links to remove it [OK]

Common Mistakes:

• Not updating previous node's next pointer
• Not updating next node's previous pointer
• Deleting wrong node without checking value

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

easy

A. void deleteByValue(Node** head, int val) { /* code */ }

B. int deleteByValue(Node head, int val) { /* code */ }

C. void deleteByValue(Node* head, int val) { /* code */ }

D. Node deleteByValue(Node** head, int val) { /* code */ }

Solution

1. Step 1: Understand pointer usage for head modification

   Since deleting a node may change the head pointer, we pass a pointer to the head pointer (Node** head).

2. Step 2: Confirm function return type

   The function deletes a node and does not return a node or int, so return type is void.

3. Final Answer:

   void deleteByValue(Node** head, int val) { /* code */ } -> Option A

4. Quick Check:

   Use double pointer to modify head [OK]

Hint: Use Node** to allow head pointer changes [OK]

Common Mistakes:

• Passing head as single pointer when head may change
• Returning wrong type from delete function
• Not using void when no return needed

3. What will be the output list after deleting value 3 from the doubly linked list: 1 <-> 3 <-> 5 <-> 3 <-> 7?

medium

A. 1 <-> 3 <-> 5 <-> 7

B. 3 <-> 5 <-> 3 <-> 7

C. 1 <-> 5 <-> 7

D. 1 <-> 5 <-> 3 <-> 7

Solution

1. Step 1: Identify which node is deleted

   Deleting by value removes the first node with value 3, which is the second node in the list.

2. Step 2: Update links and list after deletion

   After removing the first 3, the list becomes 1 <-> 5 <-> 3 <-> 7, keeping the second 3 intact.

3. Final Answer:

   1 <-> 5 <-> 3 <-> 7 -> Option D

4. Quick Check:

   Only first matching node deleted [OK]

Hint: Delete only first matching node by value [OK]

Common Mistakes:

• Deleting all nodes with value 3 instead of first
• Not updating links correctly after deletion
• Deleting wrong node (like last 3 instead of first)

4. Given this code snippet to delete a node by value, what is the error?

void deleteByValue(Node** head, int val) {
  Node* temp = *head;
  while (temp != NULL && temp->data != val) {
    temp = temp->next;
  }
  if (temp == NULL) return;
  if (temp->prev != NULL) temp->prev->next = temp->next;
  if (temp->next != NULL) temp->next->prev = temp->prev;
  free(temp);
}

medium

A. Loops infinitely when value not found

B. Does not free memory of deleted node

C. Does not update head if first node is deleted

D. Deletes all nodes with matching value

Solution

1. Step 1: Check head update when deleting first node

   If the node to delete is the head, the head pointer must be updated to the next node, but this code does not do that.

2. Step 2: Confirm other parts are correct

   Memory is freed, loop ends correctly, and only one node is deleted, so no other errors.

3. Final Answer:

   Does not update head if first node is deleted -> Option C

4. Quick Check:

   Update head pointer when deleting first node [OK]

Hint: Always update head if deleting first node [OK]

Common Mistakes:

• Forgetting to update head pointer
• Not freeing memory after deletion
• Incorrect loop causing infinite iteration

5. You have a doubly linked list with nodes: 10 <-> 20 <-> 30 <-> 40. You want to delete the node with value 10 and then insert a new node with value 5 at the head. What will be the final list?

hard

A. 5 <-> 20 <-> 30 <-> 40

B. 10 <-> 5 <-> 20 <-> 30 <-> 40

C. 20 <-> 30 <-> 40 <-> 5

D. 5 <-> 10 <-> 20 <-> 30 <-> 40

Solution

1. Step 1: Delete node with value 10 (head node)

   Removing the head node 10 updates the head pointer to node 20, so list becomes 20 <-> 30 <-> 40.

2. Step 2: Insert new node with value 5 at head

   Create a new node with value 5, set its next to current head (20), update 20's prev to new node, and update head pointer to new node.

3. Step 3: Final list after operations

   The list is now 5 <-> 20 <-> 30 <-> 40.

4. Final Answer:

   5 <-> 20 <-> 30 <-> 40 -> Option A

5. Quick Check:

   Delete head, then insert new head [OK]

Hint: Delete head, then insert new node at head [OK]

Common Mistakes:

• Not updating head after deletion
• Not linking new node correctly at head
• Appending new node at tail instead of head