Delete Node by Value in DSA Python - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output after deleting a node by value in a singly linked list

What is the printed state of the linked list after deleting the node with value 3?

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):
        if not self.head:
            self.head = Node(val)
            return
        current = self.head
        while current.next:
            current = current.next
        current.next = Node(val)

    def delete_by_value(self, val):
        current = self.head
        if current and current.val == val:
            self.head = current.next
            return
        prev = None
        while current and current.val != val:
            prev = current
            current = current.next
        if current:
            prev.next = current.next

    def print_list(self):
        current = self.head
        result = []
        while current:
            result.append(str(current.val))
            current = current.next
        print(" -> ".join(result) + " -> null")

ll = LinkedList()
for v in [1, 2, 3, 4, 5]:
    ll.append(v)
ll.delete_by_value(3)
ll.print_list()

A 1 -> 2 -> 4 -> 5 -> null

B 1 -> 2 -> 3 -> 4 -> 5 -> null

C 2 -> 3 -> 4 -> 5 -> null

D 1 -> 2 -> 4 -> null

💡 Hint

Think about how the node with value 3 is removed and how the links are updated.

The node with value 3 is found and removed by linking the previous node (2) to the next node (4). The list after deletion is 1 -> 2 -> 4 -> 5 -> null.

❓ Predict Output

intermediate

Output after deleting the head node by value

What is the printed state of the linked list after deleting the node with value 1 (head node)?

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):
        if not self.head:
            self.head = Node(val)
            return
        current = self.head
        while current.next:
            current = current.next
        current.next = Node(val)

    def delete_by_value(self, val):
        current = self.head
        if current and current.val == val:
            self.head = current.next
            return
        prev = None
        while current and current.val != val:
            prev = current
            current = current.next
        if current:
            prev.next = current.next

    def print_list(self):
        current = self.head
        result = []
        while current:
            result.append(str(current.val))
            current = current.next
        print(" -> ".join(result) + " -> null")

ll = LinkedList()
for v in [1, 2, 3, 4, 5]:
    ll.append(v)
ll.delete_by_value(1)
ll.print_list()

A 1 -> 2 -> 3 -> 4 -> 5 -> null

B 2 -> 3 -> 4 -> 5 -> null

C 1 -> 3 -> 4 -> 5 -> null

D 2 -> 3 -> 4 -> null

💡 Hint

Deleting the head node means the head pointer moves to the next node.

The head node with value 1 is deleted by moving the head pointer to the next node (2). The list after deletion is 2 -> 3 -> 4 -> 5 -> null.

🔧 Debug

advanced

Identify the error in delete_by_value method

What error will occur when deleting a node by value in the following code if the value is not found in the list?

DSA Python

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

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

    def delete_by_value(self, val):
        current = self.head
        if current and current.val == val:
            self.head = current.next
            return
        prev = None
        while current and current.val != val:
            prev = current
            current = current.next
        prev.next = current.next

ll = LinkedList()
for v in [1, 2, 3]:
    ll.append(v)
ll.delete_by_value(4)

A AttributeError: 'NoneType' object has no attribute 'next'

B IndexError: list index out of range

C No error, node is deleted successfully

D TypeError: unsupported operand type(s) for +: 'NoneType' and 'int'

💡 Hint

Consider what happens when the value is not found and current becomes None.

If the value is not found, current becomes None. Then prev.next = current.next tries to access next of None, causing AttributeError.

❓ Predict Output

advanced

Output after deleting the last node by value

What is the printed state of the linked list after deleting the node with value 5 (last node)?

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):
        if not self.head:
            self.head = Node(val)
            return
        current = self.head
        while current.next:
            current = current.next
        current.next = Node(val)

    def delete_by_value(self, val):
        current = self.head
        if current and current.val == val:
            self.head = current.next
            return
        prev = None
        while current and current.val != val:
            prev = current
            current = current.next
        if current:
            prev.next = current.next

    def print_list(self):
        current = self.head
        result = []
        while current:
            result.append(str(current.val))
            current = current.next
        print(" -> ".join(result) + " -> null")

ll = LinkedList()
for v in [1, 2, 3, 4, 5]:
    ll.append(v)
ll.delete_by_value(5)
ll.print_list()

A 1 -> 2 -> 3 -> 4 -> 5 -> null

B 1 -> 2 -> 3 -> null

C 1 -> 2 -> 3 -> 4 -> null

D 2 -> 3 -> 4 -> 5 -> null

💡 Hint

Deleting the last node means the previous node's next becomes None.

The node with value 5 is removed by setting the next of node 4 to None. The list after deletion is 1 -> 2 -> 3 -> 4 -> null.

🧠 Conceptual

expert

Why is it important to handle deletion of the head node separately?

In the delete_by_value method, why do we check if the head node contains the value before traversing the list?

A Because the head node does not have a next pointer

B Because the head node cannot be deleted in a singly linked list

C Because the head node is always the last node in the list

D Because deleting the head node requires updating the head pointer to the next node

💡 Hint

Think about what changes when the first node is removed.

The head pointer must be updated to the next node when the head node is deleted, so it requires special handling.