Delete Node at End in DSA Python - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output after deleting the last node from a singly linked list

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

DSA Python

class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

class LinkedList:
    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

    def delete_end(self):
        if not self.head:
            return
        if not self.head.next:
            self.head = None
            return
        second_last = self.head
        while second_last.next.next:
            second_last = second_last.next
        second_last.next = None

    def print_list(self):
        current = self.head
        while current:
            print(current.data, end=' -> ' if current.next else ' -> null\n')
            current = current.next

ll = LinkedList()
ll.append(10)
ll.append(20)
ll.append(30)
ll.delete_end()
ll.print_list()

A 10 -> 20 -> null

B 10 -> 20 -> 30 -> null

C 20 -> 30 -> null

D 10 -> null

💡 Hint

Deleting the last node removes the node with value 30.

The list initially is 10 -> 20 -> 30 -> null. After deleting the last node (30), the list becomes 10 -> 20 -> null.

❓ Predict Output

intermediate

Output after deleting the last node from a single-node linked list

What is the printed state of the 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.next = None

class LinkedList:
    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

    def delete_end(self):
        if not self.head:
            return
        if not self.head.next:
            self.head = None
            return
        second_last = self.head
        while second_last.next.next:
            second_last = second_last.next
        second_last.next = None

    def print_list(self):
        if not self.head:
            print('null')
            return
        current = self.head
        while current:
            print(current.data, end=' -> ' if current.next else ' -> null\n')
            current = current.next

ll = LinkedList()
ll.append(100)
ll.delete_end()
ll.print_list()

A Error: Cannot delete from empty list

B 100 -> null

C 100 -> 100 -> null

D null

💡 Hint

Deleting the only node results in an empty list.

The list initially has one node with value 100. After deleting the last node, the list becomes empty, so printing shows null only.

🔧 Debug

advanced

Identify the error in deleting the last node

What error does this code raise when trying to delete the last node from a linked list with two nodes?

DSA Python

class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

class LinkedList:
    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

    def delete_end(self):
        if not self.head:
            return
        current = self.head
        while current:
            current = current.next
        current.next = None

ll = LinkedList()
ll.append(1)
ll.append(2)
ll.delete_end()

A AttributeError: 'NoneType' object has no attribute 'next'

B No error, list becomes 1 -> null

C TypeError: 'int' object is not callable

D IndexError: list index out of range

💡 Hint

Check how the loop moves to the last node and what happens next.

The code traverses past the last node to None, then tries to set current.next = None, causing AttributeError because current is None and has no 'next' attribute.

🧠 Conceptual

advanced

Why do we need to traverse to the second last node to delete the last node?

In a singly linked list, why must we stop at the second last node to delete the last node?

A Because the head node always points to the second last node

B Because the second last node's next pointer needs to be set to None to remove the last node

C Because the last node cannot be accessed directly without the second last node's data

D Because the last node's next pointer points to the second last node

💡 Hint

Think about how nodes are connected in a singly linked list.

In a singly linked list, each node points only to the next node. To remove the last node, we must set the second last node's next pointer to None, effectively cutting off the last node.

❓ Predict Output

expert

Output after multiple deletions at the end

What is the printed state of the linked list after deleting the last node three times from the initial list 5 -> 10 -> 15 -> 20 -> 25 -> null?

DSA Python

class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

class LinkedList:
    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

    def delete_end(self):
        if not self.head:
            return
        if not self.head.next:
            self.head = None
            return
        second_last = self.head
        while second_last.next.next:
            second_last = second_last.next
        second_last.next = None

    def print_list(self):
        current = self.head
        while current:
            print(current.data, end=' -> ' if current.next else ' -> null\n')
            current = current.next

ll = LinkedList()
for value in [5, 10, 15, 20, 25]:
    ll.append(value)

ll.delete_end()
ll.delete_end()
ll.delete_end()
ll.print_list()

A 5 -> 10 -> 15 -> null

B 5 -> null

C 5 -> 10 -> null

D 5 -> 10 -> 15 -> 20 -> null

💡 Hint

Each deletion removes the last node, so after three deletions, three nodes are removed.

Initial list: 5 -> 10 -> 15 -> 20 -> 25 -> null After 1st deletion: 5 -> 10 -> 15 -> 20 -> null After 2nd deletion: 5 -> 10 -> 15 -> null After 3rd deletion: 5 -> 10 -> null