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

Delete by Value in Doubly Linked List

📖 Scenario: Imagine you have a playlist of songs where you can move forward and backward easily. This playlist is like a doubly linked list where each song knows the next and previous songs. Sometimes, you want to remove a specific song by its name.

🎯 Goal: You will build a simple doubly linked list of songs and write code to delete a song by its name (value). Finally, you will print the playlist after deletion.

📋 What You'll Learn

Create a doubly linked list with exact song names

Add a variable to hold the song name to delete

Write code to delete the node with the given song name

Print the playlist after deletion in forward order

💡 Why This Matters

🌍 Real World

Doubly linked lists are used in music players, web browsers (back and forward buttons), and undo-redo features where you need to move both ways easily.

💼 Career

Understanding how to manipulate linked lists is fundamental 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 class with a nested Node class. Then create a DoublyLinkedList object called playlist. Add these exact songs in order: "SongA", "SongB", "SongC", "SongD" using the append method.

DSA Java

// Define Node class and DoublyLinkedList class
// Create playlist and append songs "SongA", "SongB", "SongC", "SongD"
// Your code here

Hint

Define Node inside DoublyLinkedList. Use append to add songs at the end.

2

Add the Song Name to Delete

Create a String variable called songToDelete and set it to "SongC".

DSA Java

class DoublyLinkedList {
    class Node {
        String data;
        Node prev;
        Node next;
        Node(String data) {
            this.data = data;
            this.prev = null;
            this.next = null;
        }
    }

    Node head;
    Node tail;

    DoublyLinkedList() {
        head = null;
        tail = null;
    }

    void append(String data) {
        Node newNode = new Node(data);
        if (head == null) {
            head = newNode;
            tail = newNode;
        } else {
            tail.next = newNode;
            newNode.prev = tail;
            tail = newNode;
        }
    }
}

public class Main {
    public static void main(String[] args) {
        DoublyLinkedList playlist = new DoublyLinkedList();
        playlist.append("SongA");
        playlist.append("SongB");
        playlist.append("SongC");
        playlist.append("SongD");
        // Create songToDelete variable here
        // Your code here
    }
}

Hint

Just create a String variable with the exact name and value.

3

Write the Delete by Value Method

Add a method deleteByValue inside DoublyLinkedList that takes a String value and deletes the first node with that value. Use current to traverse from head. Update prev and next pointers correctly. Handle deleting head, tail, and middle nodes.

DSA Java

class DoublyLinkedList {
    class Node {
        String data;
        Node prev;
        Node next;
        Node(String data) {
            this.data = data;
            this.prev = null;
            this.next = null;
        }
    }

    Node head;
    Node tail;

    DoublyLinkedList() {
        head = null;
        tail = null;
    }

    void append(String data) {
        Node newNode = new Node(data);
        if (head == null) {
            head = newNode;
            tail = newNode;
        } else {
            tail.next = newNode;
            newNode.prev = tail;
            tail = newNode;
        }
    }

    // Add deleteByValue method here
    // Your code here
}

public class Main {
    public static void main(String[] args) {
        DoublyLinkedList playlist = new DoublyLinkedList();
        playlist.append("SongA");
        playlist.append("SongB");
        playlist.append("SongC");
        playlist.append("SongD");
        String songToDelete = "SongC";
    }
}

Hint

Traverse from head using current. When you find the node with matching data, update pointers of previous and next nodes. Handle if node is head or tail.

4

Delete the Song and Print the Playlist

Call playlist.deleteByValue(songToDelete) to delete the song. Then print the playlist from head to tail using a Node variable current. Print each song's name followed by " -> ". After the last song, print "null".

DSA Java

class DoublyLinkedList {
    class Node {
        String data;
        Node prev;
        Node next;
        Node(String data) {
            this.data = data;
            this.prev = null;
            this.next = null;
        }
    }

    Node head;
    Node tail;

    DoublyLinkedList() {
        head = null;
        tail = null;
    }

    void append(String data) {
        Node newNode = new Node(data);
        if (head == null) {
            head = newNode;
            tail = newNode;
        } else {
            tail.next = newNode;
            newNode.prev = tail;
            tail = newNode;
        }
    }

    void deleteByValue(String value) {
        Node current = head;
        while (current != null) {
            if (current.data.equals(value)) {
                if (current.prev != null) {
                    current.prev.next = current.next;
                } else {
                    head = current.next;
                }
                if (current.next != null) {
                    current.next.prev = current.prev;
                } else {
                    tail = current.prev;
                }
                break;
            }
            current = current.next;
        }
    }
}

public class Main {
    public static void main(String[] args) {
        DoublyLinkedList playlist = new DoublyLinkedList();
        playlist.append("SongA");
        playlist.append("SongB");
        playlist.append("SongC");
        playlist.append("SongD");
        String songToDelete = "SongC";
        // Call deleteByValue and print playlist
        // Your code here
    }
}

Hint

Call deleteByValue with songToDelete. Then use a loop to print each song followed by " -> ". End with "null".

Practice

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

easy

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

B. All nodes are deleted regardless of value

C. Only the first node is deleted no matter the 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 A

4. Quick Check:

   Deleting by value removes matching node [OK]

Hint: Find node by value, then update previous and next links [OK]

Common Mistakes:

• Not updating both previous and next pointers
• Deleting all nodes instead of one
• Ignoring the case when node is head or tail

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

easy

A. int deleteByValue(int value) { /* code */ }

B. void deleteByValue(int value) { /* code */ }

C. deleteByValue(int value) { /* code */ }

D. void deleteByValue() { /* code */ }

Solution

1. Step 1: Check method return type and parameters

   The method should accept an integer value to delete and return nothing, so void return type is correct.

2. Step 2: Verify method signature syntax

   Java requires return type before method name and parameter types inside parentheses.

3. Final Answer:

   void deleteByValue(int value) { /* code */ } -> Option B

4. Quick Check:

   Method with void return and int parameter is correct [OK]

Hint: Method must specify return type and parameter types in Java [OK]

Common Mistakes:

• Omitting return type
• Missing parameter type
• Using wrong return type for delete method

3. Given the doubly linked list: 10 <-> 20 <-> 30 <-> 40 <-> null, what is the list after deleting the node with value 30?

medium

A. 10 <-> 20 <-> 40 <-> null

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

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

D. 10 <-> 40 <-> null

Solution

1. Step 1: Identify node with value 30

   Traverse the list and find the node containing 30 between 20 and 40.

2. Step 2: Remove node 30 and update links

   Set 20's next pointer to 40 and 40's previous pointer to 20, removing 30 from the chain.

3. Final Answer:

   10 <-> 20 <-> 40 <-> null -> Option A

4. Quick Check:

   Node 30 removed, links updated correctly [OK]

Hint: Remove node and link previous to next nodes directly [OK]

Common Mistakes:

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

4. What is the error in this code snippet for deleting a node by value in a doubly linked list?

void deleteByValue(int value) {
  Node current = head;
  while (current != null && current.data != value) {
    current = current.next;
  }
  if (current == null) return;
  current.prev.next = current.next;
  current.next.prev = current.prev;
}

medium

A. It reverses the list instead of deleting

B. It does not check if current is null before accessing pointers

C. It deletes all nodes with the value instead of one

D. It does not handle deletion when current is head

Solution

1. Step 1: Analyze deletion at head node

   If current is head, current.prev is null, so current.prev.next causes NullPointerException.

2. Step 2: Identify missing condition for head deletion

   Code must check if current.prev is null and update head pointer accordingly.

3. Final Answer:

   It does not handle deletion when current is head -> Option D

4. Quick Check:

   Head deletion needs special handling [OK]

Hint: Check if node is head before updating previous pointer [OK]

Common Mistakes:

• Not handling head or tail nodes separately
• Accessing null pointers without checks
• Assuming node always has previous and next

5. You have a doubly linked list: 5 <-> 10 <-> 15 <-> 20 <-> 25 <-> null. You want to delete the node with value 5, then delete the node with value 25. What is the final list?

hard

A. null

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

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

D. 10 <-> 15 <-> 20 <-> 25 <-> null

Solution

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

   Since 5 is head, update head to 10 and set 10's prev to null.

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

   Since 25 is tail, update 20's next to null, removing 25.

3. Final Answer:

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

4. Quick Check:

   Head and tail deletions handled correctly [OK]

Hint: Update head or tail pointers when deleting first or last node [OK]

Common Mistakes:

• Not updating head when deleting first node
• Not updating tail when deleting last node
• Breaking links causing list corruption