Delete by Value in Doubly Linked List in DSA Javascript - Build from Scratch

Delete by Value in Doubly Linked List

📖 Scenario: You are managing a playlist of songs using a doubly linked list. Each song has a unique name. Sometimes, you want to remove a song from the playlist by its name.

🎯 Goal: Build a doubly linked list of songs, then delete a song by its name, and finally print the playlist to see the updated order.

📋 What You'll Learn

Create a doubly linked list with exact songs: 'SongA', 'SongB', 'SongC', 'SongD'

Create a variable called songToDelete with the value 'SongC'

Write a function deleteByValue that deletes the first node with the given song name

Print the playlist after deletion in the format: SongA <-> SongB <-> SongD <-> null

💡 Why This Matters

🌍 Real World

Doubly linked lists are used in music players, browsers, and other apps to move forward and backward through items efficiently.

💼 Career

Understanding linked lists and how to manipulate them is fundamental for software engineering roles involving data structures and memory management.

1

Create the Doubly Linked List

Create a doubly linked list with nodes containing these exact song names in order: 'SongA', 'SongB', 'SongC', 'SongD'. Use a class Node with properties data, prev, and next. Also create a class DoublyLinkedList with a property head initialized to null. Add a method append to add nodes at the end. Append the songs in the given order.

DSA Javascript

// Define Node and DoublyLinkedList classes
// Append 'SongA', 'SongB', 'SongC', 'SongD' to the list
// Your code here

Hint

Define Node and DoublyLinkedList classes first. Then add an append method to add nodes at the end. Finally, append the four songs in order.

2

Set the Song to Delete

Create a variable called songToDelete and set it to the string 'SongC'.

DSA Javascript

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

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

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

const playlist = new DoublyLinkedList();
playlist.append('SongA');
playlist.append('SongB');
playlist.append('SongC');
playlist.append('SongD');

// Create variable songToDelete with value 'SongC'
// Your code here

Hint

Just create a constant variable named songToDelete and assign it the string 'SongC'.

3

Write the Delete by Value Function

Add a method deleteByValue to the DoublyLinkedList class. It should take a parameter value and delete the first node whose data equals value. Handle these cases: deleting the head node, deleting a middle node, deleting the last node, and if the value is not found do nothing.

DSA Javascript

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

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

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

    // Add deleteByValue method here
    // Your code here
}

const playlist = new DoublyLinkedList();
playlist.append('SongA');
playlist.append('SongB');
playlist.append('SongC');
playlist.append('SongD');

const songToDelete = 'SongC';

Hint

Traverse the list to find the node with data === value. If found, update pointers of previous and next nodes to remove it. If it's the head, update this.head. Stop after deleting the first match.

4

Delete the Song and Print the Playlist

Call the deleteByValue method on playlist with songToDelete as argument. Then print the playlist from head to end in this exact format: each song name separated by <-> and ending with null. For example: SongA <-> SongB <-> SongD <-> null

DSA Javascript

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

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

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

    deleteByValue(value) {
        let current = this.head;
        while (current) {
            if (current.data === value) {
                if (current.prev) {
                    current.prev.next = current.next;
                } else {
                    this.head = current.next;
                }
                if (current.next) {
                    current.next.prev = current.prev;
                }
                return;
            }
            current = current.next;
        }
    }
}

const playlist = new DoublyLinkedList();
playlist.append('SongA');
playlist.append('SongB');
playlist.append('SongC');
playlist.append('SongD');

const songToDelete = 'SongC';

// Delete the song and print the playlist
// Your code here

Hint

Call playlist.deleteByValue(songToDelete). Then loop from playlist.head to build a string of song names separated by <-> and ending with null. Print the string.

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