Delete Node by Value in DSA Java - Build from Scratch

Delete Node by Value in a Singly Linked List

📖 Scenario: Imagine you have a list of tasks to do, and you want to remove a specific task by its name from your list.

🎯 Goal: You will build a simple singly linked list of tasks and write code to delete a node by its value (task name).

📋 What You'll Learn

Create a singly linked list with 4 nodes containing exact task names

Add a variable to hold the task name to delete

Write code to delete the node with the given task name

Print the linked list after deletion

💡 Why This Matters

🌍 Real World

Linked lists are used in many applications like task scheduling, undo functionality, and managing playlists where items need to be added or removed dynamically.

💼 Career

Understanding linked list operations like deletion is fundamental for software developers working with data structures, improving problem-solving and coding interview skills.

1

Create the Singly Linked List

Create a singly linked list with nodes containing these exact task names in order: "Laundry", "Groceries", "Homework", "Exercise". Use the class Node with String data and Node next. Create a variable head pointing to the first node.

DSA Java

class Node {
    String data;
    Node next;

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

public class Main {
    public static void main(String[] args) {
        // Create nodes and link them
        // Your code here
    }
}

Hint

Start by creating the first node and assign it to head. Then link the next nodes one by one.

2

Add the Task Name to Delete

Add a variable called taskToDelete and set it to the exact string "Homework".

DSA Java

class Node {
    String data;
    Node next;

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

public class Main {
    public static void main(String[] args) {
        Node head = new Node("Laundry");
        head.next = new Node("Groceries");
        head.next.next = new Node("Homework");
        head.next.next.next = new Node("Exercise");
        // Add taskToDelete variable
        // Your code here
    }
}

Hint

Declare a String variable named taskToDelete and assign it the value "Homework".

3

Delete the Node by Value

Write code to delete the node with data equal to taskToDelete from the linked list starting at head. Use variables current and previous to traverse the list. Update head if the first node is deleted.

DSA Java

        Node current = head;
        Node previous = null;
        while (current != null) {
            if (current.data.equals(taskToDelete)) {
                if (previous == null) {
                    head = current.next;
                } else {
                    previous.next = current.next;
                }
                break;
            }
            previous = current;
            current = current.next;
        }
        // Print the linked list

Hint

Use a while loop to find the node with matching data. If it is the first node, update head. Otherwise, link the previous node to the next node to remove the current.

4

Print the Linked List After Deletion

Print the linked list starting from head by traversing nodes and printing their data separated by " -> ". End with null.

DSA Java

Hint

Use a while loop to print each node's data followed by " -> ". After the loop, print null.

Practice

1. What is the main purpose of the Delete Node by Value operation in a linked list?

easy

A. Reverse the linked list

B. Add a new node with the given value to the end of the list

C. Find the position of the node with the given value

D. Remove the first node that contains the given value from the list

Solution

1. Step 1: Understand the operation goal

   The operation aims to remove a node that matches a specific value from the linked list.

2. Step 2: Identify the correct description

   Removing the first node with the given value matches Remove the first node that contains the given value from the list, while other options describe different operations.

3. Final Answer:

   Remove the first node that contains the given value from the list -> Option D

4. Quick Check:

   Delete Node by Value = Remove matching node [OK]

Hint: Deleting by value means removing matching node, not adding [OK]

Common Mistakes:

• Confusing delete with add operation
• Thinking it finds position instead of deleting
• Assuming it reverses the list

2. Which of the following is the correct Java syntax to start deleting a node by value from a singly linked list named head with value val?

easy

A. Node current = head; while(current != null && current.value != val) { current = current.next; }

B. Node current = head; while(current.value != val) { current = current.next; }

C. Node current = head; while(current.next != null && current.next.value != val) { current = current.next; }

D. Node current = head; if(current.value == val) { head = head.next; }

Solution

1. Step 1: Understand traversal to find node before target

   To delete a node by value, we need to find the node before the target node to change its next pointer.

2. Step 2: Check which loop finds the previous node

   Node current = head; while(current.next != null && current.next.value != val) { current = current.next; } correctly loops while current.next is not null and its value is not the target, so current stops at the node before the target.

3. Final Answer:

   Node current = head; while(current.next != null && current.next.value != val) { current = current.next; } -> Option C

4. Quick Check:

   Find previous node with current.next check = Node current = head; while(current.next != null && current.next.value != val) { current = current.next; } [OK]

Hint: Loop to node before target uses current.next, not current [OK]

Common Mistakes:

• Checking current.value instead of current.next.value
• Not handling head node deletion separately
• Using while loop without null check causing errors

3. What will be the output linked list after deleting the node with value 3 from the list: 1 -> 2 -> 3 -> 4 -> null?

medium

A. 1 -> 2 -> 4 -> null

B. 1 -> 3 -> 4 -> null

C. 2 -> 3 -> 4 -> null

D. 1 -> 2 -> 3 -> 4 -> null

Solution

1. Step 1: Locate node with value 3

   The node with value 3 is the third node in the list: 1 -> 2 -> 3 -> 4 -> null.

2. Step 2: Remove node with value 3 by linking previous to next

   We link node with value 2 directly to node with value 4, skipping the node with value 3.

3. Final Answer:

   1 -> 2 -> 4 -> null -> Option A

4. Quick Check:

   Deleted node 3, list skips it = 1 -> 2 -> 4 -> null [OK]

Hint: Skip node with value by linking previous to next [OK]

Common Mistakes:

• Not updating links, leaving deleted node in list
• Deleting wrong node by value
• Confusing node values and positions

4. Consider this Java code snippet to delete a node by value from a singly linked list:

Node current = head;
while(current.next != null && current.next.value != val) {
    current = current.next;
}
if(current.next.value == val) {
    current.next = current.next.next;
}

What error can occur when deleting the node if the value val is not present in the list?

medium

A. NullPointerException at current.next.value

B. IndexOutOfBoundsException at current.next.next

C. Compilation error due to missing semicolon

D. No error, deletion works fine

Solution

1. Step 1: Analyze loop exit condition

   The loop stops when current.next == null or current.next.value == val. If val is not found, current.next becomes null.

2. Step 2: Check the if condition usage

   The code checks current.next.value == val without verifying if current.next is null, causing NullPointerException if val is missing.

3. Final Answer:

   NullPointerException at current.next.value -> Option A

4. Quick Check:

   Accessing value of null next node causes NullPointerException [OK]

Hint: Always check for null before accessing next.value [OK]

Common Mistakes:

• Assuming node always found, skipping null check
• Confusing runtime exceptions with compile errors
• Ignoring loop exit conditions

5. Given a singly linked list head with nodes 10 -> 20 -> 30 -> 40 -> 50 -> null, what will be the list after deleting the node with value 10 (the head node)?

hard

A. null

B. 20 -> 30 -> 40 -> 50 -> null

C. 30 -> 40 -> 50 -> null

D. 10 -> 20 -> 30 -> 40 -> 50 -> null

Solution

1. Step 1: Identify head node deletion case

   The node to delete is the head node with value 10, so we must update head to point to the next node.

2. Step 2: Update head pointer to next node

   Set head = head.next, which points to node with value 20, effectively removing the original head.

3. Final Answer:

   20 -> 30 -> 40 -> 50 -> null -> Option B

4. Quick Check:

   Deleting head means head moves to next node [OK]

Hint: Deleting head means move head pointer to next node [OK]

Common Mistakes:

• Not updating head pointer when deleting first node
• Removing wrong node by mistake
• Assuming list becomes empty after head deletion