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 holds the name of a song. Sometimes, you want to remove a song by its name from the playlist.

🎯 Goal: Build a doubly linked list of songs, then delete a song by its name, and finally print the updated playlist.

📋 What You'll Learn

Create a doubly linked list with exact song names in order

Add a variable to hold the song name to delete

Write a function to delete the first node with the given song name

Print the playlist after deletion showing all songs in order

💡 Why This Matters

🌍 Real World

Managing playlists, browser history, or undo-redo stacks often uses doubly linked lists where nodes need to be added or removed by value.

💼 Career

Understanding how to manipulate doubly linked lists is important for software engineers working with low-level data structures, memory management, and performance-critical applications.

1

Create the Doubly Linked List with Songs

Create a doubly linked list with nodes containing these exact song names in order: "SongA", "SongB", "SongC", "SongD". Use the struct Node with string data, Node* prev, and Node* next. Create a pointer head pointing to the first node.

DSA C++

#include 
#include 
using namespace std;

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

int main() {
    // Create nodes for SongA, SongB, SongC, SongD and link them
    // Your code here
    return 0;
}

Hint

Start by creating the first node with "SongA" and set head to it. Then create the next nodes, linking prev and next pointers properly.

2

Add the Song Name to Delete

Add a string variable called songToDelete and set it to "SongC".

DSA C++

#include 
#include 
using namespace std;

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

int main() {
    Node* head = new Node{"SongA", nullptr, nullptr};
    Node* node2 = new Node{"SongB", head, nullptr};
    head->next = node2;
    Node* node3 = new Node{"SongC", node2, nullptr};
    node2->next = node3;
    Node* node4 = new Node{"SongD", node3, nullptr};
    node3->next = node4;

    // Add the song name to delete
    // Your code here
    return 0;
}

Hint

Just create a string variable songToDelete and assign it the value "SongC".

3

Write the Delete by Value Logic

Write code to delete the first node in the doubly linked list whose data matches songToDelete. Use a pointer current to traverse from head. Update the prev and next pointers of neighboring nodes to remove the node. If the node to delete is head, update head accordingly. Free the deleted node's memory using delete.

DSA C++

#include 
#include 
using namespace std;

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

int main() {
    Node* head = new Node{"SongA", nullptr, nullptr};
    Node* node2 = new Node{"SongB", head, nullptr};
    head->next = node2;
    Node* node3 = new Node{"SongC", node2, nullptr};
    node2->next = node3;
    Node* node4 = new Node{"SongD", node3, nullptr};
    node3->next = node4;

    string songToDelete = "SongC";

    // Delete the node with data equal to songToDelete
    // Your code here
    return 0;
}

Hint

Traverse the list with current. When you find the node with data == songToDelete, update pointers of neighbors and delete the node. Remember to handle if the node is the head.

4

Print the Updated Playlist

Print the updated doubly linked list starting from head. Use a pointer temp to traverse. Print each song's data followed by " -> ". After the last song, print "null".

DSA C++

#include 
#include 
using namespace std;

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

int main() {
    Node* head = new Node{"SongA", nullptr, nullptr};
    Node* node2 = new Node{"SongB", head, nullptr};
    head->next = node2;
    Node* node3 = new Node{"SongC", node2, nullptr};
    node2->next = node3;
    Node* node4 = new Node{"SongD", node3, nullptr};
    node3->next = node4;

    string songToDelete = "SongC";

    Node* current = head;
    while (current != nullptr) {
        if (current->data == songToDelete) {
            if (current->prev != nullptr) {
                current->prev->next = current->next;
            } else {
                head = current->next;
            }
            if (current->next != nullptr) {
                current->next->prev = current->prev;
            }
            delete current;
            break;
        }
        current = current->next;
    }

    // Print the updated playlist
    // Your code here
    return 0;
}

Hint

Use a pointer temp starting at head. While temp is not nullptr, print temp->data followed by " -> ". Move temp to temp->next. After the loop, print "null".

Practice

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

easy

A. All nodes are deleted regardless of value.

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

C. Only the first node is deleted without checking 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:

   Delete by value removes matching node [OK]

Hint: Find node, update previous and next pointers [OK]

Common Mistakes:

• Not updating both previous and next pointers
• Deleting node without checking value
• Deleting all nodes instead of one

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 deleteNode(Node* &head, int val) { /* code */ }

B. void deleteNode(int val) { /* code */ }

C. Node deleteNode(int val) { /* code */ }

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

Solution

1. Step 1: Understand parameter passing for head pointer

   Head pointer must be passed by reference to allow modification if the first node is deleted.

2. Step 2: Check function return type

   Deletion functions usually return void as they modify the list in place.

3. Final Answer:

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

4. Quick Check:

   Pass head by reference and return void [OK]

Hint: Pass head by reference to modify list [OK]

Common Mistakes:

• Passing head by value causing no list update
• Returning Node instead of void
• Missing head pointer parameter

3. What is the output of the following code snippet after deleting value 20 from the doubly linked list?

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

// List: 10 <-> 20 <-> 30
// deleteNode(head, 20);
// printList(head);

medium

A. 10 <-> null

B. 10 <-> 20 <-> 30 <-> null

C. 20 <-> 30 <-> null

D. 10 <-> 30 <-> null

Solution

1. Step 1: Identify node to delete

   Node with value 20 is in the middle of the list 10 <-> 20 <-> 30.

2. Step 2: Update links after deletion

   After deleting 20, 10's next points to 30, and 30's prev points to 10.

3. Final Answer:

   10 <-> 30 <-> null -> Option D

4. Quick Check:

   Middle node deleted, links updated [OK]

Hint: Deleting middle node links neighbors directly [OK]

Common Mistakes:

• Not updating previous pointer of next node
• Not updating next pointer of previous node
• Leaving deleted node linked

4. Identify the bug in this delete by value function for doubly linked list:

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

medium

A. Does not check for null head pointer

B. Deletes all nodes with matching value

C. Does not update head if first node is deleted

D. Deletes node without freeing memory

Solution

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

   If the node to delete is the head, head pointer must be updated to next node.

2. Step 2: Verify code for head update

   Code does not update head pointer when temp->prev is nullptr (first node).

3. Final Answer:

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

4. Quick Check:

   Head update missing for first node deletion [OK]

Hint: Update head if deleting first node [OK]

Common Mistakes:

• Forgetting to update head pointer
• Not handling empty list
• Deleting without checking node existence

5. Given a doubly linked list with nodes: 5 <-> 10 <-> 15 <-> 20, what will be the list after deleting value 5 and then value 20?

hard

A. 10 <-> 15 <-> null

B. 5 <-> 10 <-> 15 <-> 20 <-> null

C. 10 <-> 15 <-> 20 <-> null

D. 15 <-> null

Solution

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

   Update head to 10, set 10's prev to nullptr. List becomes 10 <-> 15 <-> 20.

2. Step 2: Delete node with value 20 (tail node)

   Update 15's next to nullptr. List becomes 10 <-> 15.

3. Final Answer:

   10 <-> 15 <-> null -> Option A

4. Quick Check:

   Deleted head and tail nodes correctly [OK]

Hint: Update head and tail pointers when deleting ends [OK]

Common Mistakes:

• Not updating head when deleting first node
• Not updating tail when deleting last node
• Leaving dangling pointers