Delete by Value in Doubly Linked List in DSA Java - Execution Trace

Concept Flow - Delete by Value in Doubly Linked List

Start at head

↓

Check if head is null

↓

Traverse nodes

↓

Is current node's value == target?

No→Move to next node

Yes↓

Adjust pointers of prev and next nodes

↓

Delete current node

↓

Stop traversal

↓

Done

Start from the head, move through nodes until the target value is found, then adjust pointers to remove that node and stop.

Execution Sample

DSA Java

class Node {
  int val;
  Node prev, next;
}

void deleteByValue(Node head, int val) {
  // traverse and delete node with val
}

This code deletes the first node with the given value from a doubly linked list.

Execution Table

Step	Operation	Current Node Value	Pointer Changes	Visual State
1	Start at head	1	None	1 <-> 2 <-> 3 <-> 4 <-> null
2	Check if current node value == 3	1	None	1 <-> 2 <-> 3 <-> 4 <-> null
3	Move to next node	2	None	1 <-> 2 <-> 3 <-> 4 <-> null
4	Check if current node value == 3	2	None	1 <-> 2 <-> 3 <-> 4 <-> null
5	Move to next node	3	None	1 <-> 2 <-> 3 <-> 4 <-> null
6	Found node with value 3	3	prev.next = 4; next.prev = 2	1 <-> 2 <-> 4 <-> null
7	Delete node 3 and stop	3	Node 3 removed	1 <-> 2 <-> 4 <-> null
8	End	null	None	1 <-> 2 <-> 4 <-> null

💡 Node with value 3 found and deleted; traversal stops.

Variable Tracker

Variable	Start	After Step 3	After Step 5	After Step 6	Final
current	Node(1)	Node(2)	Node(3)	null	null
head	Node(1)	Node(1)	Node(1)	Node(1)	Node(1)
list size	4	4	4	3	3

Key Moments - 3 Insights

Why do we adjust both prev.next and next.prev pointers when deleting a node?

Because the list is doubly linked, we must update the previous node's next pointer and the next node's prev pointer to bypass the deleted node, as shown in step 6 of the execution_table.

What happens if the node to delete is the head node?

If the head node matches the value, we update the head pointer to head.next and set the new head's prev to null. This is a special case not shown here but follows the same pointer adjustment logic.

Why do we stop traversal immediately after deleting the node?

Because the task is to delete the first occurrence of the value, once found and deleted (step 7), continuing traversal is unnecessary.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of 'current' after step 5?

A Node with value 3

B Node with value 2

C Node with value 4

D null

💡 Hint

Check the 'Current Node Value' column at step 5 in the execution_table.

At which step does the list size decrease?

A Step 3

B Step 7

C Step 6

D Step 8

💡 Hint

Look at the 'list size' variable in variable_tracker after each step.

If the node with value 3 was not found, what would happen to the 'current' variable?

A It would stay at the head node

B It would become null after traversing all nodes

C It would point to the last node indefinitely

D It would cause an error

💡 Hint

Consider the traversal logic in concept_flow and how 'current' moves through nodes.

Concept Snapshot

Delete by Value in Doubly Linked List:
- Start at head node
- Traverse nodes until value found
- Adjust prev.next and next.prev to remove node
- Handle special cases (head or tail)
- Stop after first deletion
- List size decreases by one

Full Transcript

To delete a node by value in a doubly linked list, start at the head and move through each node checking its value. When the node with the target value is found, update the previous node's next pointer and the next node's prev pointer to skip the current node. This removes the node from the list. If the node is the head, update the head pointer accordingly. After deletion, stop traversal because only the first occurrence is removed. The list size decreases by one. This process ensures the list remains connected correctly after deletion.

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