Delete Node by Value in DSA Javascript

Mental Model

We find the node with the value to remove and change the previous node to skip it.

Analogy: Imagine a chain of paper clips linked together. To remove one clip, you unhook it from the one before it, so the chain stays connected without that clip.

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

Dry Run Walkthrough

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

Goal: Remove the node with value 3 and keep the list connected

Step 1: start at head node with value 1

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

Why: We begin searching from the first node

Step 2: move to next node with value 2

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

Why: Value 1 is not 3, so continue searching

Step 3: move to next node with value 3

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

Why: Found the node with value 3 to delete

Step 4: change node with value 2 to point to node with value 4, skipping 3

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

Why: Removing node 3 by skipping it in the chain

Result:

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

Annotated Code

DSA Javascript

class Node {
  constructor(value) {
    this.value = value;
    this.next = null;
  }
}

class LinkedList {
  constructor() {
    this.head = null;
  }

  append(value) {
    const newNode = new Node(value);
    if (!this.head) {
      this.head = newNode;
      return;
    }
    let curr = this.head;
    while (curr.next) {
      curr = curr.next;
    }
    curr.next = newNode;
  }

  deleteByValue(value) {
    if (!this.head) return; // empty list

    if (this.head.value === value) {
      this.head = this.head.next; // remove head
      return;
    }

    let curr = this.head;
    while (curr.next && curr.next.value !== value) {
      curr = curr.next; // advance to node before target
    }

    if (curr.next && curr.next.value === value) {
      curr.next = curr.next.next; // skip the node to delete
    }
  }

  printList() {
    let curr = this.head;
    let result = '';
    while (curr) {
      result += curr.value + ' -> ';
      curr = curr.next;
    }
    result += 'null';
    console.log(result);
  }
}

// Driver code
const list = new LinkedList();
list.append(1);
list.append(2);
list.append(3);
list.append(4);

list.deleteByValue(3);
list.printList();

if (!this.head) return; // empty list

handle empty list case

if (this.head.value === value) { this.head = this.head.next; // remove head return; }

remove head node if it matches value

while (curr.next && curr.next.value !== value) { curr = curr.next; // advance to node before target }

find node before the one to delete

if (curr.next && curr.next.value === value) { curr.next = curr.next.next; // skip the node to delete }

unlink the node with target value

Output

1 -> 2 -> 4 -> null

Complexity Analysis

Time: O(n) because we may need to check each node once to find the value

Space: O(1) because we only use a few pointers, no extra space grows with input

vs Alternative: Compared to rebuilding the list without the value, this method changes links directly, saving time and space

Edge Cases

empty list

nothing happens, no error

DSA Javascript

if (!this.head) return; // empty list

value is at head

head moves to next node, removing first node

DSA Javascript

if (this.head.value === value) {
  this.head = this.head.next; // remove head
  return;
}

value not found

list stays unchanged

DSA Javascript

while (curr.next && curr.next.value !== value) {
  curr = curr.next; // advance to node before target
}

When to Use This Pattern

When you need to remove a specific value from a linked list, use the delete-by-value pattern to unlink the node without breaking the chain.

Common Mistakes

Mistake: Trying to delete the node by changing the current node instead of the previous node's next pointer
Fix: Always find the node before the target and change its next pointer to skip the target node

Mistake: Not handling deletion when the node to remove is the head
Fix: Check if head node matches value and update head pointer accordingly

Summary

Deletes the first node with a given value by changing links to skip it.

Use when you want to remove a node by its value from a singly linked list.

The key is to link the previous node directly to the node after the one to delete.

Practice

1. What is the main purpose of the deleteNodeByValue function in a linked list?

easy

A. To reverse the linked list

B. To add a new node with the given value at the end of the list

C. To find the position of a node with the given value

D. To remove the first node that contains the given value from the list

Solution

1. Step 1: Understand the function's goal

   The function aims to remove a node that matches a specific value from the linked list.

2. Step 2: Identify the action performed

   Deleting a node by value means finding the first node with that value and removing it from the list.

3. Final Answer:

   To remove the first node that contains the given value from the list -> Option D

4. Quick Check:

   Delete node by value = Remove node with value [OK]

Hint: Deleting by value means removing matching node, not adding [OK]

Common Mistakes:

• Confusing deletion with insertion
• Thinking it finds position only
• Assuming it reverses the list

2. Which of the following is the correct way to check if the head node contains the value to delete in JavaScript?

easy

A. if (head.value === value) { /* delete head */ }

B. if (head == value) { /* delete head */ }

C. if (head.value = value) { /* delete head */ }

D. if (head.value != value) { /* delete head */ }

Solution

1. Step 1: Understand comparison syntax in JavaScript

   Use triple equals (===) to compare values strictly without type coercion.

2. Step 2: Identify correct condition for head node value check

   Check if head.value equals the target value using ===.

3. Final Answer:

   if (head.value === value) { /* delete head */ } -> Option A

4. Quick Check:

   Use === for value comparison [OK]

Hint: Use === to compare values, not = or == [OK]

Common Mistakes:

• Using single = which assigns instead of compares
• Using == which can cause unexpected type coercion
• Comparing head node directly to value without .value

3. Consider the linked list: 10 -> 20 -> 30 -> 40 -> null. After calling deleteNodeByValue(head, 30), what will be the new list?

medium

A. 20 -> 30 -> 40 -> null

B. 10 -> 20 -> 30 -> 40 -> null

C. 10 -> 20 -> 40 -> null

D. 10 -> 30 -> 40 -> null

Solution

1. Step 1: Locate the node with value 30

   Traverse the list: 10, 20, then 30 is found as the third node.

2. Step 2: Remove the node with value 30

   Adjust the previous node's next pointer (20's next) to point to 40, skipping 30.

3. Final Answer:

   10 -> 20 -> 40 -> null -> Option C

4. Quick Check:

   Deleted 30 node, list skips it [OK]

Hint: Skip node by linking previous to next [OK]

Common Mistakes:

• Not updating previous node's next pointer
• Deleting wrong node or none
• Confusing node values or order

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

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

medium

A. It causes an infinite loop when value is not found

B. It does not handle deleting the head node if it matches the value

C. It deletes all nodes with the given value instead of just one

D. It throws an error if the list is empty

Solution

1. Step 1: Analyze head node deletion case

   The code starts checking from current.next, so it never checks if head itself has the value.

2. Step 2: Identify missing head deletion handling

   If the head node contains the value, it won't be deleted, causing incorrect behavior.

3. Final Answer:

   It does not handle deleting the head node if it matches the value -> Option B

4. Quick Check:

   Head node deletion missing = Bug [OK]

Hint: Always check head node separately before loop [OK]

Common Mistakes:

• Assuming loop covers head node
• Ignoring empty list case
• Thinking it deletes all matching nodes

5. You have a singly linked list: 5 -> 10 -> 15 -> 10 -> 20 -> null. You want to delete the first node with value 10. After deletion, what is the correct list?

hard

A. 5 -> 15 -> 10 -> 20 -> null

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

C. 5 -> 15 -> 20 -> null

D. 10 -> 15 -> 10 -> 20 -> null

Solution

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

   Traverse from head: 5 (no), then 10 (yes) at second node.

2. Step 2: Delete the first 10 node

   Link 5's next pointer to 15, skipping the first 10 node.

3. Final Answer:

   5 -> 15 -> 10 -> 20 -> null -> Option A

4. Quick Check:

   Only first 10 removed, rest remain [OK]

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

Common Mistakes:

• Deleting all nodes with value 10
• Deleting wrong 10 node
• Breaking list links incorrectly