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

Delete by Value in Doubly Linked List

📖 Scenario: Imagine you have a playlist of songs where you can move forward and backward between songs. This playlist is like a doubly linked list where each song knows the next and previous song. Sometimes, you want to remove a song by its name from the playlist.

🎯 Goal: You will build a doubly linked list to represent the playlist and write code to delete a song by its name (value). Finally, you will print the playlist to see the updated order of songs.

📋 What You'll Learn

Create a doubly linked list with exact songs in order

Add a variable to hold the song name to delete

Write code to delete the first occurrence of the song by its name

Print the playlist from head to tail showing song names separated by ' <-> ' and ending with ' <-> None'

💡 Why This Matters

🌍 Real World

Doubly linked lists are used in music players, web browsers, and undo-redo features where you need to move forward and backward efficiently.

💼 Career

Understanding linked lists and how to manipulate them is fundamental for software developers working with data structures, memory management, and performance optimization.

1

Create the doubly linked list with songs

Create a class called Node with attributes data, prev, and next. Then create a class called DoublyLinkedList with an attribute head initialized to None. Add a method append to add nodes to the end. Finally, create a DoublyLinkedList object called playlist and append these songs in order: 'SongA', 'SongB', 'SongC', 'SongD', 'SongE'.

DSA Python

# Define Node and DoublyLinkedList classes
# Create playlist and append songs 'SongA', 'SongB', 'SongC', 'SongD', 'SongE'
# Your code here

Hint

Start by defining the Node class with data, prev, and next. Then define DoublyLinkedList with a head attribute and an append method to add nodes at the end. Finally, create the playlist and add the songs in the given order.

2

Add the song name to delete

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

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 self.head is None:
            self.head = new_node
            return
        last = self.head
        while last.next:
            last = last.next
        last.next = new_node
        new_node.prev = last

playlist = DoublyLinkedList()
playlist.append('SongA')
playlist.append('SongB')
playlist.append('SongC')
playlist.append('SongD')
playlist.append('SongE')

# Create a variable song_to_delete and set it to 'SongC'
# Your code here

Hint

Just create a variable named song_to_delete and assign the string 'SongC' to it.

3

Write code to delete the song by value

Add a method called delete_by_value inside the DoublyLinkedList class that takes value as a parameter. This method should find the first node with data == value and remove it from the list by updating the prev and next pointers. Then call playlist.delete_by_value(song_to_delete) to delete the song.

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 self.head is None:
            self.head = new_node
            return
        last = self.head
        while last.next:
            last = last.next
        last.next = new_node
        new_node.prev = last

    # Add delete_by_value method here

playlist = DoublyLinkedList()
playlist.append('SongA')
playlist.append('SongB')
playlist.append('SongC')
playlist.append('SongD')
playlist.append('SongE')

song_to_delete = 'SongC'

# Call delete_by_value method to delete the song
# Your code here

Hint

Inside delete_by_value, start from head and move forward until you find the node with the matching value. Then update the prev and next pointers of neighboring nodes to remove it. Handle the case if the node to delete is the head. Finally, call the method with song_to_delete.

4

Print the playlist after deletion

Add a method called print_list inside the DoublyLinkedList class that prints the playlist from head to tail. Each song should be printed followed by ' <-> '. After the last song, print None. Then call playlist.print_list() to display the updated playlist.

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 self.head is None:
            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

    # Add print_list method here

playlist = DoublyLinkedList()
playlist.append('SongA')
playlist.append('SongB')
playlist.append('SongC')
playlist.append('SongD')
playlist.append('SongE')

song_to_delete = 'SongC'

playlist.delete_by_value(song_to_delete)

# Call print_list method to display playlist
# Your code here

Hint

In print_list, start from head and print each node's data followed by ' <-> '. After the last node, print 'None'. Then call playlist.print_list() to show the updated playlist.

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