Delete Node by Value in DSA Java - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the main goal when deleting a node by value in a linked list?

To find the first node with the given value and remove it from the list by adjusting the links so the list remains connected.

beginner

Why do we need to handle the head node separately when deleting by value?

Because the head node has no previous node, so if it matches the value, we must update the head pointer to the next node.

beginner

In Java, what happens if you try to delete a node by value that does not exist in the linked list?

The list remains unchanged because no node matches the value, so no links are updated.

intermediate

What is the time complexity of deleting a node by value in a singly linked list?

O(n), where n is the number of nodes, because you may need to traverse the entire list to find the node.

beginner

Show the basic steps to delete a node by value in a singly linked list.

1. Check if the list is empty. 2. If head node has the value, update head to head.next. 3. Otherwise, traverse the list to find the node with the value. 4. Keep track of previous node to update its next pointer. 5. If found, set previous.next to current.next to remove the node.

What should you do if the head node contains the value to delete?

A Update the head pointer to the next node

B Do nothing

C Delete the entire list

D Swap head with the last node

If the head node contains the value, you must update the head pointer to the next node to remove it.

What is the role of the 'previous' pointer when deleting a node by value?

A To find the node after the one to delete

B To update its next pointer to skip the deleted node

C To store the value of the node to delete

D To point to the head node

The previous pointer helps update its next link to skip the node being deleted.

If the value to delete is not found in the list, what happens?

A The head node is deleted

B The last node is deleted

C An error is thrown

D The list remains unchanged

If the value is not found, no nodes are removed and the list stays the same.

What is the time complexity of deleting a node by value in a singly linked list?

A O(log n)

B O(1)

C O(n)

D O(n^2)

You may need to traverse the entire list to find the node, so time complexity is O(n).

Which of these is NOT a step in deleting a node by value?

A Create a new node with the value

B Update the previous node's next pointer

C Traverse the list to find the node

D Update head if the node to delete is the head

Creating a new node is not part of deleting a node by value.

Explain how to delete a node by value in a singly linked list step-by-step.

Think about how to keep the list connected after removing the node.

What special cases must you consider when deleting a node by value in a linked list?

Consider what happens at the start and if the value is missing.

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