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

Time Complexity: Delete by Value in Doubly Linked List

O(n)

Understanding Time Complexity

We want to understand how long it takes to remove a value from a doubly linked list.

How does the time needed change when the list gets bigger?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

function deleteByValue(head, value) {
  let current = head;
  while (current !== null) {
    if (current.data === value) {
      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 the list for the first node with the given value and removes it by updating pointers.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Traversing the list nodes one by one 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 value grows roughly in direct proportion.

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 list size.

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 a node by value is always very fast, like O(1)."

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

Interview Connect

Understanding this helps you explain how linked lists work and how searching affects performance in real tasks.

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 node with the matching value is removed and links are updated

B. All nodes are deleted regardless of value

C. Only the first node is deleted no matter the value

D. The list is reversed instead of deleting

Solution

1. Step 1: Locate the node with the given value

   Traverse the list from head to tail to find the node whose value matches the target.

2. Step 2: Remove the node and update links

   Adjust the previous node's next pointer and the next node's previous pointer to bypass the deleted node.

3. Final Answer:

   The node with the matching value is removed and links are updated -> Option A

4. Quick Check:

   Delete by value means remove matching node [OK]

Hint: Delete node by value means remove matching node and fix links [OK]

Common Mistakes:

• Deleting all nodes instead of one
• Not updating previous or next pointers
• Deleting wrong node when multiple have same value

2. Which of the following is the correct way to check if the current node's value matches the target value in JavaScript?

easy

A. if (current.value != target) {}

B. if (current.value == target) {}

C. if (current.value = target) {}

D. if (current.value === target) {}

Solution

1. Step 1: Understand JavaScript equality operators

   Use === for strict equality to avoid type coercion and ensure exact match.

2. Step 2: Identify correct syntax for comparison

   if (current.value === target) correctly compares values and types.

3. Final Answer:

   if (current.value === target) {} -> Option D

4. Quick Check:

   Use strict equality (===) for value comparison [OK]

Hint: Use === for exact value and type match in JavaScript [OK]

Common Mistakes:

• Using single = which assigns instead of compares
• Using == which allows type coercion
• Using != which checks inequality

3. Consider this doubly linked list: 10 <-> 20 <-> 30 <-> 40. After deleting the node with value 30, what is the new list?

medium

A. 10 <-> 20 <-> 30 <-> 40

B. 10 <-> 20 <-> 40

C. 20 <-> 30 <-> 40

D. 10 <-> 30 <-> 40

Solution

1. Step 1: Identify node to delete

   The node with value 30 is located between 20 and 40.

2. Step 2: Remove node 30 and update links

   Set 20's next pointer to 40 and 40's previous pointer to 20, skipping 30.

3. Final Answer:

   10 <-> 20 <-> 40 -> Option B

4. Quick Check:

   Deleted 30, linked 20 and 40 directly [OK]

Hint: Remove node and link neighbors directly [OK]

Common Mistakes:

• Not updating previous pointer of next node
• Leaving deleted node linked in list
• Deleting wrong node

4. Given this code snippet to delete a node by value, what is the error?

function deleteByValue(head, value) {
  let current = head;
  while (current !== null) {
    if (current.value === value) {
      current.prev.next = current.next;
      current.next.prev = current.prev;
      break;
    }
    current = current.next;
  }
  return head;
}

medium

A. It uses assignment instead of comparison

B. It never breaks the loop

C. It does not handle deleting the head node correctly

D. It returns null always

Solution

1. Step 1: Analyze deletion of head node

   If the node to delete is the head, current.prev is null, so current.prev.next causes error.

2. Step 2: Identify missing head update

   Code should update head to current.next if deleting head node to avoid broken list.

3. Final Answer:

   It does not handle deleting the head node correctly -> Option C

4. Quick Check:

   Deleting head needs special handling [OK]

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

Common Mistakes:

• Not checking if current.prev is null
• Not updating head when deleting first node
• Assuming all nodes have prev and next

5. You have a doubly linked list: 5 <-> 10 <-> 15 <-> 20 <-> 25. You want to delete the node with value 5 (head) and then the node with value 25 (tail). What is the final list?

hard

A. 10 <-> 15 <-> 20

B. 5 <-> 10 <-> 15 <-> 20

C. 10 <-> 15 <-> 20 <-> 25

D. 15 <-> 20

Solution

1. Step 1: Delete head node with value 5

   Update head to 10 and set 10.prev to null.

2. Step 2: Delete tail node with value 25

   Update 20.next to null, removing 25.

3. Final Answer:

   10 <-> 15 <-> 20 -> Option A

4. Quick Check:

   Removed head and tail nodes correctly [OK]

Hint: Update head or tail pointers when deleting ends [OK]

Common Mistakes:

• Not updating head when deleting first node
• Not updating tail when deleting last node
• Leaving dangling pointers