Delete by Value in Doubly Linked List in DSA Python - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output after deleting a middle value in doubly linked list

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

DSA Python

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
                return
            current = current.next

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

# Setup
dll = DoublyLinkedList()
dll.append(1)
dll.append(2)
dll.append(3)
dll.append(4)
dll.append(5)

# Delete value 3

dll.delete_by_value(3)

# Print list

dll.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 links of previous and next nodes are updated when deleting a middle node.

Deleting the node with value 3 removes it from the list. The previous node (2) points to the next node (4), and the next node (4) points back to the previous node (2). The list becomes 1 -> 2 -> 4 -> 5 -> null.

❓ Predict Output

intermediate

Output after deleting the head node by value

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

DSA Python

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
                return
            current = current.next

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

# Setup

dll = DoublyLinkedList()
dll.append(1)
dll.append(2)
dll.append(3)

# Delete value 1 (head)

dll.delete_by_value(1)

# Print list

dll.print_list()

A 3 -> null

B 2 -> 3 -> null

C 2 -> null

D 1 -> 2 -> 3 -> null

💡 Hint

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

When deleting the head node (value 1), the head pointer updates to the next node (2). The previous pointer of node 2 becomes None. The list becomes 2 -> 3 -> null.

🔧 Debug

advanced

Identify the error in delete_by_value method

What error will this code raise when trying to delete a value not present in the list?

DSA Python

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
                return
            current = current.next
        # No return or error if value not found

# Setup

dll = DoublyLinkedList()
dll.append(1)
dll.append(2)
dll.append(3)

# Delete value 4 (not in list)

dll.delete_by_value(4)

# Print list

dll.print_list()

A No error, list remains unchanged: 1 -> 2 -> 3 -> null

B TypeError due to NoneType assignment

C AttributeError because current becomes None and code tries to access current.prev

D IndexError because of invalid index access

💡 Hint

Check what happens when the value is not found in the list.

The method returns silently if the value is not found. No error occurs. The list remains unchanged.

❓ Predict Output

advanced

Output after deleting the tail node by value

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

DSA Python

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
                return
            current = current.next

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

# Setup

dll = DoublyLinkedList()
dll.append(1)
dll.append(2)
dll.append(3)
dll.append(4)
dll.append(5)

# Delete value 5 (tail)

dll.delete_by_value(5)

# Print list

dll.print_list()

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

B 1 -> 2 -> 3 -> null

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

D 2 -> 3 -> 4 -> null

💡 Hint

Deleting the tail node means the previous node's next pointer becomes None.

Deleting the tail node (value 5) removes it. The previous node (4) now points to None. The list becomes 1 -> 2 -> 3 -> 4 -> null.

🧠 Conceptual

expert

Why is updating both prev and next pointers necessary when deleting a node?

In a doubly linked list, when deleting a node by value, why must both the previous node's next pointer and the next node's prev pointer be updated?

A It is not necessary to update any pointers because garbage collection handles it

B Only the previous node's next pointer needs updating because the next node's prev pointer is not used

C Updating either pointer is enough because the other updates automatically

D To maintain the bidirectional links so traversal in both directions remains correct

💡 Hint

Think about how nodes connect forward and backward in a doubly linked list.

In a doubly linked list, each node has links to both previous and next nodes. When deleting a node, both links must be updated to keep the list connected correctly in both directions. Otherwise, traversing backward or forward may fail or cause errors.