Delete from End of Doubly Linked List in DSA Python - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output after deleting last node from doubly linked list

What is the printed state of the doubly linked list after deleting the last node?

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 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_from_end(self):
        if not self.head:
            return
        if not self.head.next:
            self.head = None
            return
        last = self.head
        while last.next:
            last = last.next
        last.prev.next = None

    def print_list(self):
        if not self.head:
            print("null")
            return
        current = self.head
        result = []
        while current:
            result.append(str(current.data))
            current = current.next
        print(" -> ".join(result) + " -> null")

# Setup
dll = DoublyLinkedList()
dll.append(10)
dll.append(20)
dll.append(30)
dll.delete_from_end()
dll.print_list()

A 20 -> 30 -> null

B 10 -> 20 -> 30 -> null

C 10 -> 20 -> null

D 10 -> null

💡 Hint

Think about what happens to the last node and the previous node's next pointer.

The last node (30) is removed. The previous node (20) now points to null, so the list ends at 20.

❓ Predict Output

intermediate

Output after deleting last node from single-node doubly linked list

What is the printed state of the doubly linked list after deleting the last node when the list has only one node?

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 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_from_end(self):
        if not self.head:
            return
        if not self.head.next:
            self.head = None
            return
        last = self.head
        while last.next:
            last = last.next
        last.prev.next = None

    def print_list(self):
        if not self.head:
            print("null")
            return
        current = self.head
        result = []
        while current:
            result.append(str(current.data))
            current = current.next
        print(" -> ".join(result) + " -> null")

# Setup
single_node_list = DoublyLinkedList()
single_node_list.append(100)
single_node_list.delete_from_end()
single_node_list.print_list()

A null

B 100 -> null

C Error

D 100

💡 Hint

Deleting the only node should leave the list empty.

When the only node is deleted, the head becomes None, so printing the list shows nothing, represented as 'null'.

🔧 Debug

advanced

Identify the error in delete_from_end method

Which option contains the error that will cause a broken list when deleting the last node from a doubly linked list with two nodes?

DSA Python

def delete_from_end(self):
    if not self.head:
        return
    if not self.head.next:
        self.head = None
        return
    last = self.head
    while last.next:
        last = last.next
    last.prev = None  # Error here

A last.prev = None # Incorrect, breaks list

B last.prev.next = None # Correctly removes last node

C last.next = None # Correctly removes last node

D self.head = None # Incorrect, deletes entire list

💡 Hint

Think about which pointer needs to be updated to remove the last node properly.

Setting last.prev = None breaks the link from the previous node to the last node but does not remove the last node from the list, causing a broken list.

🧠 Conceptual

advanced

Effect of deleting last node on doubly linked list pointers

After deleting the last node from a doubly linked list, which pointers are updated to maintain list integrity?

A The previous node's prev pointer is set to None.

B The head pointer is set to None regardless of list size.

C The last node's next pointer is set to the head node.

D The previous node's next pointer is set to None; the last node is removed.

💡 Hint

Consider what happens to the node before the last node after deletion.

The previous node's next pointer must be set to None to indicate the new end of the list after the last node is removed.

❓ Predict Output

expert

Output after multiple deletions from end of doubly linked list

What is the printed state of the doubly linked list after deleting the last node three times in a row?

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 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_from_end(self):
        if not self.head:
            return
        if not self.head.next:
            self.head = None
            return
        last = self.head
        while last.next:
            last = last.next
        last.prev.next = None

    def print_list(self):
        if not self.head:
            print("null")
            return
        current = self.head
        result = []
        while current:
            result.append(str(current.data))
            current = current.next
        print(" -> ".join(result) + " -> null")

# Setup
dll = DoublyLinkedList()
dll.append(1)
dll.append(2)
dll.append(3)
dll.append(4)
dll.append(5)
dll.delete_from_end()
dll.delete_from_end()
dll.delete_from_end()
dll.print_list()

A 3 -> 4 -> 5 -> null

B 1 -> 2 -> null

C 1 -> 2 -> 3 -> null

D null

💡 Hint

Each deletion removes the last node; track the list after each removal.

Starting with 1->2->3->4->5, deleting last node thrice removes 5, then 4, then 3, leaving 1->2->null.