Delete Node by Value in DSA Python

Mental Model

To remove a node with a specific value, find it by moving through the list, then change the previous node to skip it.

Analogy: Imagine a chain of paper clips linked together. To remove one clip, you unhook the clip before it and link it directly to the clip after the one you want to remove.

head -> 1 -> 2 -> 3 -> 4 -> null
          ↑

Dry Run Walkthrough

Input: list: 1 -> 2 -> 3 -> 4, delete value 3

Goal: Remove the node containing value 3 from the list

Step 1: start at head node with value 1

head -> [curr->1] -> 2 -> 3 -> 4 -> null

Why: We begin searching from the start of the list

Step 2: move curr to node with value 2, keep track of previous node (1)

head -> 1 -> [curr->2] -> 3 -> 4 -> null

Why: Check next node to find the target value

Step 3: move curr to node with value 3, previous is 2

head -> 1 -> 2 -> [curr->3] -> 4 -> null

Why: Found the node to delete

Step 4: change previous node's next pointer to skip curr and point to curr's next (4)

head -> 1 -> 2 -> 4 -> null

Why: By skipping the node with value 3, it is removed from the list

Result:

head -> 1 -> 2 -> 4 -> null

Annotated Code

DSA Python

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

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

    def append(self, val):
        new_node = Node(val)
        if not self.head:
            self.head = new_node
            return
        curr = self.head
        while curr.next:
            curr = curr.next
        curr.next = new_node

    def delete_by_value(self, val):
        curr = self.head
        prev = None
        while curr:
            if curr.val == val:
                if prev:
                    prev.next = curr.next  # skip current node
                else:
                    self.head = curr.next  # delete head node
                return
            prev = curr
            curr = curr.next

    def __str__(self):
        vals = []
        curr = self.head
        while curr:
            vals.append(str(curr.val))
            curr = curr.next
        return ' -> '.join(vals) + ' -> null'

# Driver code
ll = LinkedList()
for v in [1, 2, 3, 4]:
    ll.append(v)
print("Before deletion:", ll)
ll.delete_by_value(3)
print("After deletion:", ll)

while curr:

traverse nodes until end or target found

if curr.val == val:

check if current node holds the value to delete

if prev: prev.next = curr.next # skip current node else: self.head = curr.next # delete head node

remove current node by linking previous node to next, or update head if deleting first node

prev = curr curr = curr.next

advance pointers to continue search

Output

Before deletion: 1 -> 2 -> 3 -> 4 -> null

After deletion: 1 -> 2 -> 4 -> null

Complexity Analysis

Time: O(n) because in worst case we traverse all n nodes once to find the value

Space: O(1) because we only use a few pointers regardless of list size

vs Alternative: Compared to rebuilding the list without the value, this method removes the node in one pass with no extra space

Edge Cases

empty list

nothing happens, list remains empty

DSA Python

while curr:

value not found

list remains unchanged after full traversal

DSA Python

while curr:

value is at head node

head pointer updates to next node, removing first node

DSA Python

else:
    self.head = curr.next  # delete head node

When to Use This Pattern

When you need to remove a specific value from a linked list, use the delete-by-value pattern to find and unlink the node efficiently.

Common Mistakes

Mistake: Not updating the head when the node to delete is the first node
Fix: Add a check to update the head pointer when prev is None

Mistake: Skipping updating the previous node's next pointer, leaving the node still linked
Fix: Set prev.next to curr.next to unlink the target node

Summary

Deletes the first node with a given value from a linked list.

Use when you want to remove a specific value from anywhere in the list.

Remember to handle the special case when the node to delete is the head.

Practice

1. What does the operation Delete Node by Value do in a linked list?

easy

A. Removes the first node that contains the given value

B. Adds a new node with the given value at the end

C. Finds the node with the given value without removing it

D. Reverses the linked list

Solution

1. Step 1: Understand the operation

   Deleting a node by value means removing the first node that matches the given value from the linked list.

2. Step 2: Compare options

   Only Removes the first node that contains the given value describes removing the first node with the given value. Others describe different operations.

3. Final Answer:

   Removes the first node that contains the given value -> Option A

4. Quick Check:

   Delete Node by Value = Remove first matching node [OK]

Hint: Delete node by value removes first matching node [OK]

Common Mistakes:

• Confusing deletion by value with adding a node
• Thinking it deletes all nodes with the value
• Mixing deletion by value with reversing the list

2. Which of the following is the correct Python syntax to delete a node by value from a singly linked list?

easy

A. def delete_node(head, value):
current = head
while current:
if current.val == value:
current = current.next
break
current = current.next

B. def delete_node(head, value):
prev = None
current = head
while current:
if current.val == value:
if prev:
prev.next = current.next
else:
head = current.next
break
prev = current
current = current.next
return head

C. def delete_node(head, value):
for node in head:
if node.val == value:
head.remove(node)
break
return head

D. def delete_node(head, value):
head = [x for x in head if x != value]
return head

Solution

1. Step 1: Analyze the deletion logic

   Deleting a node requires tracking the previous node to update its next pointer. def delete_node(head, value): prev = None current = head while current: if current.val == value: if prev: prev.next = current.next else: head = current.next break prev = current current = current.next return head correctly uses prev and current pointers and updates links properly.

2. Step 2: Check other options

   def delete_node(head, value): current = head while current: if current.val == value: current = current.next break current = current.next only moves current pointer without changing links. def delete_node(head, value): for node in head: if node.val == value: head.remove(node) break return head uses invalid iteration on linked list nodes. def delete_node(head, value): head = [x for x in head if x != value] return head treats linked list as a list, which is incorrect.

3. Final Answer:

   Option B code correctly deletes node by value in a singly linked list -> Option B

4. Quick Check:

   Proper pointer update = def delete_node(head, value): prev = None current = head while current: if current.val == value: if prev: prev.next = current.next else: head = current.next break prev = current current = current.next return head [OK]

Hint: Use prev and current pointers to update links [OK]

Common Mistakes:

• Not updating previous node's next pointer
• Trying to iterate linked list like a Python list
• Not returning updated head after deletion

3. What will be the output linked list after deleting value 3 from the list: 1 -> 3 -> 5 -> 3 -> 7 -> null?

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

def delete_node(head, value):
    prev = None
    current = head
    while current:
        if current.val == value:
            if prev:
                prev.next = current.next
            else:
                head = current.next
            break
        prev = current
        current = current.next
    return head

# Create list
head = Node(1)
head.next = Node(3)
head.next.next = Node(5)
head.next.next.next = Node(3)
head.next.next.next.next = Node(7)

head = delete_node(head, 3)

# Print list
current = head
result = []
while current:
    result.append(current.val)
    current = current.next
print(result)

medium

A. [1, 5, 3, 7]

B. [1, 3, 5, 7]

C. [3, 5, 3, 7]

D. [1, 5, 7]

Solution

1. Step 1: Identify the first node with value 3

   The list is 1 -> 3 -> 5 -> 3 -> 7. The first node with value 3 is the second node.

2. Step 2: Delete the first 3 and link previous node to next

   After deletion, the list becomes 1 -> 5 -> 3 -> 7.

3. Final Answer:

   [1, 5, 3, 7] -> Option A

4. Quick Check:

   First 3 removed, rest unchanged = [1, 5, 3, 7] [OK]

Hint: Delete only first matching node, keep rest intact [OK]

Common Mistakes:

• Deleting all nodes with value 3 instead of first only
• Not updating head when first node matches
• Skipping nodes after deletion

4. The following code tries to delete a node by value from a linked list but causes an error. What is the error?

def delete_node(head, value):
    current = head
    while current.next:
        if current.next.val == value:
            current.next = current.next.next
            break
        current = current.next
    return head

medium

A. Fails when the value is not found

B. Fails when the list is empty

C. Fails when the node to delete is the last node

D. Fails when the node to delete is the head node

Solution

1. Step 1: Analyze deletion logic

   The code checks current.next.val to find the node to delete, so it cannot delete the head node if it matches the value.

2. Step 2: Check edge cases

   If the head node has the value, the code never deletes it because it only looks at current.next.

3. Final Answer:

   Fails when the node to delete is the head node -> Option D

4. Quick Check:

   Head node deletion not handled = Fails when the node to delete is the head node [OK]

Hint: Check if head node matches before loop [OK]

Common Mistakes:

• Not handling deletion of head node separately
• Assuming current.next always exists without check
• Ignoring empty list case

5. You have a singly linked list: 10 -> 20 -> 30 -> 40 -> 50 -> null. You want to delete the node with value 10 and then insert a new node with value 15 after the node with value 20. What will be the final linked list? Choose the correct sequence of operations and final list. Options: A) Delete 10, insert 15 after 20: 20 -> 15 -> 30 -> 40 -> 50 B) Delete 10, insert 15 after 20: 10 -> 20 -> 15 -> 30 -> 40 -> 50 C) Delete 10, insert 15 after 20: 20 -> 30 -> 15 -> 40 -> 50 D) Delete 10, insert 15 after 20: 15 -> 20 -> 30 -> 40 -> 50

hard

A. 20 -> 30 -> 15 -> 40 -> 50

B. 10 -> 20 -> 15 -> 30 -> 40 -> 50

C. 20 -> 15 -> 30 -> 40 -> 50

D. 15 -> 20 -> 30 -> 40 -> 50

Solution

1. Step 1: Delete node with value 10

   Since 10 is the head, deleting it makes 20 the new head. List becomes 20 -> 30 -> 40 -> 50.

2. Step 2: Insert node with value 15 after node with value 20

   Find node 20, insert 15 after it. List becomes 20 -> 15 -> 30 -> 40 -> 50.

3. Final Answer:

   20 -> 15 -> 30 -> 40 -> 50 -> Option C

4. Quick Check:

   Delete head 10, insert 15 after 20 = 20 -> 15 -> 30 -> 40 -> 50 [OK]

Hint: Delete head carefully, then insert after target node [OK]

Common Mistakes:

• Not updating head after deleting first node
• Inserting new node in wrong position
• Confusing node values and positions