Delete by Value in Doubly Linked List in DSA Python - 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

|Yes↓

Adjust prev node's next pointer

↓

Adjust next node's prev pointer

↓

Delete current node

↓

Done or continue if multiple deletions

↓

End of list reached or node deleted

Start from the head node, check each node's value. If it matches the target, update pointers of previous and next nodes to remove it, then delete the node.

Execution Sample

DSA Python

class Node:
    def __init__(self, val):
        self.val = val
        self.prev = None
        self.next = None

def delete_by_value(head, target):
    current = head
    while current:
        if current.val == target:
            if current.prev:
                current.prev.next = current.next
            if current.next:
                current.next.prev = current.prev
            if current == head:
                head = current.next
            break
        current = current.next
    return head

Deletes the first node with the target value from a doubly linked list and returns the new head.

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.val == 3	1	No change	1 <-> 2 <-> 3 <-> 4 <-> 5
3	Move to next node	2	None	1 <-> 2 <-> 3 <-> 4 <-> 5
4	Check if current.val == 3	2	No change	1 <-> 2 <-> 3 <-> 4 <-> 5
5	Move to next node	3	None	1 <-> 2 <-> 3 <-> 4 <-> 5
6	Check if current.val == 3	3	Yes, delete node	1 <-> 2 <-> 4 <-> 5
7	Adjust prev.next and next.prev	3	2.next = 4, 4.prev = 2	1 <-> 2 <-> 4 <-> 5
8	Delete current node	3	Node removed	1 <-> 2 <-> 4 <-> 5
9	Break loop and return head	N/A	None	1 <-> 2 <-> 4 <-> 5

💡 Node with value 3 found and deleted; loop exits.

Variable Tracker

Variable	Start	After Step 3	After Step 5	After Step 6	Final
current.val	1	2	3	3	N/A
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.next and next.prev pointers when deleting a node?

Because the list is doubly linked, each node points both ways. Updating prev.next skips the deleted node forward, and updating next.prev skips it backward, fully removing it from the chain (see steps 7 and 8).

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

If the current node is the head, we update the head pointer to current.next to keep the list accessible (step 6 checks and updates head).

Why do we break the loop after deleting the node?

Because this function deletes only the first occurrence of the target value. Continuing would risk errors or deleting multiple nodes unintentionally (step 9).

Visual Quiz - 3 Questions

Look at the execution table, what is the value of 'current.val' at Step 5?

A 2

B 3

C 4

D 1

💡 Hint

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

At which step does the list visually change by removing a node?

A Step 4

B Step 2

C Step 6

D Step 9

💡 Hint

Look at the 'Visual State' column and find when '3' disappears.

If the target value was not found, what would happen to the 'head' variable?

A It would remain unchanged

B It would become None

C It would point to the last node

D It would point to the deleted node

💡 Hint

Refer to the variable_tracker for 'head' and the exit condition in the execution_table.

Concept Snapshot

Delete by Value in Doubly Linked List:
- Start at head, traverse nodes
- If node.val == target:
  - Update prev.next and next.prev pointers
  - If head node, update head
  - Remove node and stop
- Return updated head
Pointers must be adjusted both ways to unlink node.

Full Transcript

This visualization shows how to delete a node by value in a doubly linked list. We start at the head node and check each node's value. When we find the node with the target value, we update the previous node's next pointer and the next node's previous pointer to skip the current node. If the node to delete is the head, we update the head pointer. Then we remove the node and stop the search. The execution table tracks each step, showing the current node, pointer changes, and the visual state of the list. The variable tracker shows how 'current' and 'head' change during execution. Key moments clarify why both pointers must be updated, what happens if the head is deleted, and why the loop breaks after deletion. The quiz tests understanding of node values at steps, when the list changes, and what happens if the target is not found.

Practice

1. What happens when you delete a node by value in a doubly linked list?

easy

A. The list is reversed instead of deleting

B. All nodes are deleted regardless of value

C. Only the first node is deleted always

D. The node with the matching value is removed and links are updated

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 D

4. Quick Check:

   Delete by value means remove matching node [OK]

Hint: Find node, update previous and next pointers [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 syntax to delete a node by value in a doubly linked list in Python?

easy

A. def delete_by_value(self, value):
current = self.head
while current:
if current.data == value:
# update links
break
current = current.next

B. def delete_by_value(value):
current = head
while current:
if current.data = value:
# update links
break
current = current.next

C. def delete_by_value(self, value):
current = self.head
while current:
if current.data == value
# update links
break
current = current.next

D. def delete_by_value(self, value):
current = self.head
while current:
if current.data == value:
# update links
continue
current = current.next

Solution

1. Step 1: Check method signature and loop

   def delete_by_value(self, value): current = self.head while current: if current.data == value: # update links break current = current.next correctly defines a method with self and value, and uses a while loop to traverse nodes.

2. Step 2: Verify condition and syntax

   def delete_by_value(self, value): current = self.head while current: if current.data == value: # update links break current = current.next uses '==' for comparison and breaks after deletion logic, which is correct syntax and logic.

3. Final Answer:

   Option A has correct syntax and logic for deletion by value -> Option A

4. Quick Check:

   Correct method and loop syntax [OK]

Hint: Use '==' for comparison and break after deletion [OK]

Common Mistakes:

• Using '=' instead of '==' in condition
• Missing colon ':' after if statement
• Not including self parameter in method

3. What will be the output of the following code after deleting value 20?

class Node:
    def __init__(self, data):
        self.data = data
        self.prev = None
        self.next = None

class DoublyLinkedList:
    def __init__(self):
        self.head = None

    def append(self, data):
        new_node = Node(data)
        if not self.head:
            self.head = new_node
            return
        last = self.head
        while last.next:
            last = last.next
        last.next = new_node
        new_node.prev = last

    def delete_by_value(self, value):
        current = self.head
        while current:
            if current.data == value:
                if current.prev:
                    current.prev.next = current.next
                else:
                    self.head = current.next
                if current.next:
                    current.next.prev = current.prev
                break
            current = current.next

    def print_list(self):
        current = self.head
        result = []
        while current:
            result.append(current.data)
            current = current.next
        print(result)

dll = DoublyLinkedList()
dll.append(10)
dll.append(20)
dll.append(30)
dll.delete_by_value(20)
dll.print_list()

medium

A. [10]

B. [10, 20, 30]

C. [10, 30]

D. [20, 30]

Solution

1. Step 1: Append nodes 10, 20, 30

   The list becomes 10 <-> 20 <-> 30.

2. Step 2: Delete node with value 20

   Node 20 is found and removed by updating 10's next to 30 and 30's prev to 10.

3. Final Answer:

   [10, 30] -> Option C

4. Quick Check:

   Deleted 20, list is [10, 30] [OK]

Hint: After deletion, list skips removed value [OK]

Common Mistakes:

• Not updating head when deleting first node
• Not updating prev pointer of next node
• Printing list before deletion

4. Identify the error in the following delete_by_value method for a doubly linked list:

def delete_by_value(self, value):
    current = self.head
    while current:
        if current.data == value:
            current.prev.next = current.next
            current.next.prev = current.prev
            break
        current = current.next

medium

A. Does not traverse the list correctly

B. Does not handle deletion when current is head (current.prev is None)

C. Uses break instead of continue after deletion

D. Deletes all nodes with the value instead of one

Solution

1. Step 1: Check handling of head node deletion

   If current is head, current.prev is None, so current.prev.next causes error.

2. Step 2: Confirm missing condition for head update

   Code does not update self.head when deleting the first node, causing attribute error.

3. Final Answer:

   Does not handle deletion when current is head (current.prev is None) -> Option B

4. Quick Check:

   Head deletion needs special handling [OK]

Hint: Check if node is head before updating prev pointer [OK]

Common Mistakes:

• Not checking if current.prev is None
• Assuming all nodes have prev and next
• Forgetting to update head pointer

5. Given a doubly linked list with nodes 5 <-> 10 <-> 15 <-> 20, what will be the list after deleting value 5 and then value 20?

hard

A. [10, 15]

B. [5, 10, 15, 20]

C. [15]

D. [10, 15, 20]

Solution

1. Step 1: Delete node with value 5 (head)

   After deleting 5, head moves to 10, list is 10 <-> 15 <-> 20.

2. Step 2: Delete node with value 20 (tail)

   After deleting 20, 15 becomes tail, list is 10 <-> 15.

3. Final Answer:

   [10, 15] -> Option A

4. Quick Check:

   Deleted head and tail nodes correctly [OK]

Hint: Delete head and tail carefully, update pointers [OK]

Common Mistakes:

• Not updating head after deleting first node
• Not updating tail after deleting last node
• Deleting nodes in wrong order