Delete Node by Value in DSA Java - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to check if the head node contains the value to delete.

DSA Java

if (head != null && head.data [1] value) {
    head = head.next;
    return;
}

Drag options to blanks, or click blank then click option'

A>

B!=

C==

D<

Attempts:

3 left

💡 Hint

Common Mistakes

Using '!=' instead of '==' causes the wrong node to be deleted.

Using comparison operators like '>' or '<' is incorrect here.

We check if the head node's data is equal to the value to delete. If yes, we remove the head by pointing it to the next node.

2fill in blank

medium

Complete the while loop condition to traverse the list until the next node is null or contains the value.

DSA Java

Node current = head;
while (current.next != null && current.next.data [1] value) {
    current = current.next;
}

Drag options to blanks, or click blank then click option'

A==

B<

C>

D!=

Attempts:

3 left

💡 Hint

Common Mistakes

Using '==' causes the loop to stop too early.

Using '>' or '<' is not suitable for equality checks.

We continue moving forward while the next node's data is not equal to the value. This stops at the node before the one to delete.

3fill in blank

hard

Fix the error in deleting the node by correctly updating the next pointer.

DSA Java

if (current.next != null) {
    current.next = current.next.[1];
}

Drag options to blanks, or click blank then click option'

Anext

Bprev

Cdata

Dhead

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'prev' or 'data' causes errors because those fields don't exist or are not pointers.

Using 'head' here is incorrect as it refers to the start of the list.

To delete the node, we skip it by pointing current.next to the node after the one to delete, which is current.next.next.

4fill in blank

hard

Fill both blanks to complete the method that deletes a node by value from the linked list.

DSA Java

public void deleteByValue(int value) {
    if (head == null) return;
    if (head.data [1] value) {
        head = head.[2];
        return;
    }
    Node current = head;
    while (current.next != null && current.next.data != value) {
        current = current.next;
    }
    if (current.next != null) {
        current.next = current.next.next;
    }
}

Drag options to blanks, or click blank then click option'

A==

B!=

Cnext

Dprev

Attempts:

3 left

💡 Hint

Common Mistakes

Using '!=' in the first blank causes wrong deletion logic.

Using 'prev' instead of 'next' for head update causes errors.

We check if head's data equals the value, then update head to head.next to delete it.

5fill in blank

hard

Fill all three blanks to create a method that deletes a node by value and returns true if deleted, false otherwise.

DSA Java

public boolean deleteNode(int value) {
    if (head == null) return false;
    if (head.data [1] value) {
        head = head.[2];
        return [3];
    }
    Node current = head;
    while (current.next != null && current.next.data != value) {
        current = current.next;
    }
    if (current.next != null) {
        current.next = current.next.next;
        return true;
    }
    return false;
}

Drag options to blanks, or click blank then click option'

A==

Bnext

Ctrue

Dfalse

Attempts:

3 left

💡 Hint

Common Mistakes

Returning false after deleting head is wrong.

Using '!=' instead of '==' in first blank breaks logic.

We check if head's data equals value, update head to head.next, and return true to indicate deletion.

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