Delete by Value in Doubly Linked List in DSA Python - Time & Space Complexity

Time Complexity: Delete by Value in Doubly Linked List

O(n)

Understanding Time Complexity

When deleting a node by value in a doubly linked list, we want to know how the time taken changes as the list grows.

We ask: How long does it take to find and remove a node with a given value?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

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

def delete_by_value(head, value):
    current = head
    while current:
        if current.data == value:
            # Remove current node
            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
    

This code searches for the first node with the given value and removes it from the doubly linked list.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Traversing the list node by node to find the value.
• How many times: Up to n times, where n is the number of nodes in the list.

How Execution Grows With Input

As the list grows, the time to find the node grows roughly in direct proportion to the list size.

Input Size (n)	Approx. Operations
10	Up to 10 node checks
100	Up to 100 node checks
1000	Up to 1000 node checks

Pattern observation: The number of steps grows linearly with the number of nodes.

Final Time Complexity

Time Complexity: O(n)

This means the time to delete by value grows linearly as the list gets longer.

Common Mistake

[X] Wrong: "Deleting by value in a doubly linked list is always fast and constant time because we can jump directly to the node."

[OK] Correct: We must first find the node by checking each one, which takes time proportional to the list size.

Interview Connect

Understanding this helps you explain how linked lists work and why searching affects performance, a key skill in many coding interviews.

Self-Check

"What if the list was sorted? How would that change the time complexity of deleting by value?"

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