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

Concept Flow - Delete by Value in Doubly Linked List

Start at head

↓

Check if current node's value == target?

No→Move to next node

↓

If current == null

↓

Adjust pointers of prev and next nodes

↓

Value not found, stop

↓

Delete current node

↓

Stop

Start from the head, look for the node with the target value. If found, adjust the previous and next nodes' pointers to remove it, then delete the node.

Execution Sample

DSA C

void deleteByValue(Node** head, int val) {
  Node* current = *head;
  while (current != NULL && current->data != val) {
    current = current->next;
  }
  if (current == NULL) return;
  if (current->prev) current->prev->next = current->next;
  else *head = current->next;
  if (current->next) current->next->prev = current->prev;
  free(current);
}

This code searches for a node with the given value and deletes it from the doubly linked list by adjusting pointers.

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->data == 3	1	None	1 <-> 2 <-> 3 <-> 4 <-> NULL
3	Move to next node	2	None	1 <-> 2 <-> 3 <-> 4 <-> NULL
4	Check if current->data == 3	2	None	1 <-> 2 <-> 3 <-> 4 <-> NULL
5	Move to next node	3	None	1 <-> 2 <-> 3 <-> 4 <-> NULL
6	Check if current->data == 3	3	None	1 <-> 2 <-> 3 <-> 4 <-> NULL
7	Adjust pointers to remove node 3	3	2->next = 4, 4->prev = 2	1 <-> 2 <-> 4 <-> NULL
8	Delete node 3	3	Node 3 freed	1 <-> 2 <-> 4 <-> NULL
9	Stop	NULL	None	1 <-> 2 <-> 4 <-> NULL

💡 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)	NULL
head	Node(1)	Node(1)	Node(1)	Node(1)	Node(1)
list size	4 nodes	4 nodes	4 nodes	3 nodes	3 nodes

Key Moments - 3 Insights

Why do we check if current->prev is NULL before changing pointers?

Because if current->prev is NULL, it means current is the head node. We must update the head pointer instead of current->prev->next. This is shown in step 7 where pointer changes depend on whether current->prev exists.

What happens if the value to delete is not found in the list?

The loop ends with current == NULL (step 9), and the function returns without changes. The list remains the same, as no pointer adjustments or deletions occur.

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

Because in a doubly linked list, each node points to both previous and next nodes. To remove a node cleanly, we must link its previous node to its next node and vice versa, as shown in step 7.

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 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 node to delete was the head (value 1), what pointer would be updated?

A current->prev->next

B head pointer

C current->next->prev

D No pointer changes

💡 Hint

Refer to key_moments about updating head when current->prev is NULL.

Concept Snapshot

Delete by Value in Doubly Linked List:
- Start at head, traverse nodes until value found
- If node found:
  - If prev exists, prev->next = current->next
  - Else update head to current->next
  - If next exists, next->prev = current->prev
- Free the node
- If not found, do nothing

Full Transcript

To delete a node by value in a doubly linked list, start from the head and move through nodes until you find the node with the target value. If the node is found, adjust the previous node's next pointer and the next node's previous pointer to bypass the current node. If the node is the head, update the head pointer. Finally, free the memory of the deleted node. If the value is not found, the list remains unchanged.