Delete by Value in Doubly Linked List in DSA C# - Execution Trace

Concept Flow - Delete by Value in Doubly Linked List

Start at head node

↓

Check if current node's value == target?

No→Move to next node

↓

If current == null

↓

Value not found, stop

↓

Adjust pointers of prev and next nodes

↓

Delete current node

↓

Done

Start from the head, look for the node with the target value. If found, adjust the previous and next nodes to skip it, then delete it. Stop if value not found.

Execution Sample

DSA C#

Node current = head;
while (current != null && current.Value != target) {
  current = current.Next;
}
if (current == null) return; // not found
// Adjust pointers
if (current.Prev != null) current.Prev.Next = current.Next;
if (current.Next != null) current.Next.Prev = current.Prev;
if (current == head) head = current.Next;

This code searches for a node with the target value and removes it by updating the previous and next pointers.

Execution Table

Step	Operation	Current Node Value	Pointer Changes	Visual State
1	Start at head	1	None	1 <-> 2 <-> 3 <-> 4 <-> 5
2	Check if current.Value == 3	1	None	1 <-> 2 <-> 3 <-> 4 <-> 5
3	Move to next node	2	None	1 <-> 2 <-> 3 <-> 4 <-> 5
4	Check if current.Value == 3	2	None	1 <-> 2 <-> 3 <-> 4 <-> 5
5	Move to next node	3	None	1 <-> 2 <-> 3 <-> 4 <-> 5
6	Check if current.Value == 3	3	None	1 <-> 2 <-> 3 <-> 4 <-> 5
7	Adjust pointers to remove node 3	3	2.Next = 4, 4.Prev = 2	1 <-> 2 <-> 4 <-> 5
8	Delete node 3	3	Node 3 removed	1 <-> 2 <-> 4 <-> 5
9	End	null	None	1 <-> 2 <-> 4 <-> 5

💡 Node with value 3 found and deleted; list updated accordingly.

Variable Tracker

Variable	Start	After Step 3	After Step 5	After Step 7	Final
current	Node(1)	Node(2)	Node(3)	Node(3)	Node(3)
head	Node(1)	Node(1)	Node(1)	Node(1)	Node(1)
list state	1 <-> 2 <-> 3 <-> 4 <-> 5	1 <-> 2 <-> 3 <-> 4 <-> 5	1 <-> 2 <-> 3 <-> 4 <-> 5	1 <-> 2 <-> 4 <-> 5	1 <-> 2 <-> 4 <-> 5

Key Moments - 3 Insights

Why do we need to update both prev and next pointers when deleting a node?

Because the node is connected in both directions, we must update the previous node's next pointer and the next node's prev pointer to skip the deleted node, as shown in step 7 of the execution_table.

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

If the node to delete is the head, we update the head pointer to the next node. This is handled in the code after pointer adjustments, ensuring the list remains connected.

Why do we stop searching when current becomes null?

Because reaching null means we have reached the end of the list without finding the target value, so deletion cannot proceed. This is shown in step 9 where current is null and the process ends.

Visual Quiz - 3 Questions

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

A Node with value 1

B Node with value 2

C Node with value 3

D null

💡 Hint

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

At which step do the pointers get adjusted to remove the node?

A Step 6

B Step 7

C Step 8

D Step 9

💡 Hint

Look for 'Adjust pointers' operation in the execution_table.

If the target value was not found, what would be the value of 'current' at the end?

A null

B Node with target value

C Head node

D Previous node

💡 Hint

Refer to the exit_note and step 9 where current is null if value not found.

Concept Snapshot

Delete by Value in Doubly Linked List:
- Start at head, traverse nodes to find target value.
- If found, update prev.Next and next.Prev to skip node.
- If node is head, update head pointer.
- Stop if value not found (current == null).
- List remains connected before and after deletion.

Full Transcript

To delete a node by value in a doubly linked list, start at the head node and check each node's value. If the current node's value matches the target, adjust the previous node's next pointer and the next node's previous pointer to bypass the current node. If the node to delete is the head, update the head pointer to the next node. If the target value is not found, the search ends when the current node becomes null. This process ensures the list remains connected and the target node is removed safely.

Practice

1. What happens when you delete a node by value in a doubly linked list if the value is not found?

easy

A. An error is thrown and the program stops.

B. The first node is deleted regardless of the value.

C. All nodes are deleted from the list.

D. The list remains unchanged because no node matches the value.

Solution

1. Step 1: Search for the node with the given value

   Traverse the list from head to tail to find a node matching the value.

2. Step 2: Check if node is found

   If no node matches the value, no deletion occurs and the list stays the same.

3. Final Answer:

   The list remains unchanged because no node matches the value. -> Option D

4. Quick Check:

   Delete by value with no match = no change [OK]

Hint: If value not found, list stays same [OK]

Common Mistakes:

• Assuming deletion happens even if value not found
• Trying to delete head without checking value
• Expecting an error instead of no action

2. Which of the following is the correct way to update the previous pointer when deleting a middle node in a doubly linked list in C#?

easy

A. nodeToDelete.Next.Prev = nodeToDelete.Prev;

B. nodeToDelete.Prev.Next = nodeToDelete.Next.Prev;

C. nodeToDelete.Next = nodeToDelete.Prev.Next;

D. nodeToDelete.Prev = nodeToDelete.Next.Prev;

Solution

1. Step 1: Understand pointers in doubly linked list

   When deleting a node, the next node's previous pointer must point to the deleted node's previous node.

2. Step 2: Correct pointer update

   Setting nodeToDelete.Next.Prev = nodeToDelete.Prev correctly links the next node back to the previous node.

3. Final Answer:

   nodeToDelete.Next.Prev = nodeToDelete.Prev; -> Option A

4. Quick Check:

   Update next node's Prev to deleted node's Prev [OK]

Hint: Next node's Prev points to deleted node's Prev [OK]

Common Mistakes:

• Mixing up Next and Prev pointers
• Assigning Prev to Next's Prev incorrectly
• Not updating both Next and Prev pointers

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 <-> 30 <-> 40 <-> null

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

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

D. 10 <-> 30 <-> 40 <-> null

Solution

1. Step 1: Locate 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 pointers

   Set 20's Next to 40 and 40's Prev to 20, skipping 30.

3. Final Answer:

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

4. Quick Check:

   Deleted 30, linked 20 and 40 directly [OK]

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

Common Mistakes:

• Not updating both Prev and Next pointers
• Leaving deleted node in the list
• Deleting wrong node by mistake

4. Consider this code snippet for deleting a node by value in a doubly linked list:

if (current == null) return;
if (current.Prev != null) current.Prev.Next = current.Next;
if (current.Next != null) current.Next.Prev = current.Prev;
if (current == head) head = current.Next;

What is the bug in this code?

medium

A. It may cause a null reference if current is null before checks.

B. It does not update the head when deleting the first node.

C. It does not handle deleting the last node correctly.

D. It does not remove the node from memory.

Solution

1. Step 1: Verify null safety

   The initial check if (current == null) return; and conditional pointer accesses prevent null references.

2. Step 2: Check head and pointer updates

   Head is updated correctly when deleting the first node, and pointers are linked properly for middle nodes.

3. Step 3: Identify the issue with last node

   The code sets current.Prev.Next = null but does not update a potential tail pointer to current.Prev, leaving the tail pointing to the deleted node.

4. Final Answer:

   It does not handle deleting the last node correctly. -> Option C

5. Quick Check:

   Missing tail update for last node deletion [OK]

Hint: Update tail pointer when deleting last node [OK]

Common Mistakes:

• Ignoring null checks before pointer access
• Not updating head when deleting first node
• Assuming garbage collection removes node immediately

5. You have a doubly linked list with nodes: 5 <-> 10 <-> 15 <-> 20 <-> 25 <-> null. You want to delete all nodes with values greater than 15. Which approach correctly deletes these nodes by value?

hard

A. Traverse from head, delete nodes with value > 15, updating pointers carefully.

B. Delete nodes by value without updating pointers, then reset head.

C. Only delete the first node with value > 15 and stop.

D. Traverse from tail, delete nodes with value < 15.

Solution

1. Step 1: Traverse list from head to tail

   Visit each node and check if its value is greater than 15.

2. Step 2: Delete matching nodes and update pointers

   For each node with value > 15, remove it by linking its previous node to its next node, updating both Next and Prev pointers.

3. Step 3: Continue traversal carefully

   After deletion, continue traversal without skipping nodes to delete all matching nodes.

4. Final Answer:

   Traverse from head, delete nodes with value > 15, updating pointers carefully. -> Option A

5. Quick Check:

   Delete all matching nodes with pointer updates [OK]

Hint: Traverse and delete nodes carefully, update pointers [OK]

Common Mistakes:

• Deleting nodes without updating pointers
• Stopping after first deletion
• Deleting wrong nodes by incorrect condition