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

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output after deleting the first node?

Consider a singly linked list with nodes 10 -> 20 -> 30 -> null. After deleting the node at the beginning, what is the printed state of the list?

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_at_beginning(self):
        if self.head:
            self.head = self.head.next

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

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

A null

B 10 -> 20 -> 30 -> null

C 20 -> 30 -> null

D 30 -> null

💡 Hint

Deleting at beginning removes the first node and moves head to next node.

Initially, the list is 10 -> 20 -> 30 -> null. Deleting the first node removes 10, so the new head is 20, resulting in 20 -> 30 -> null.

❓ Predict Output

intermediate

What happens when deleting from a single-node list?

Given a linked list with a single node 5 -> null, what is the printed output after deleting the node at the beginning?

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_at_beginning(self):
        if self.head:
            self.head = self.head.next

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

ll = LinkedList()
ll.append(5)
ll.delete_at_beginning()
ll.print_list()

A 5 -> null

B null

C Error

D 5

💡 Hint

Deleting the only node leaves the list empty.

After deleting the only node, the head becomes None, so printing the list shows 'null'.

🔧 Debug

advanced

Identify the error in this delete at beginning method

What error will this code produce when called on an empty list?

DSA Python

def delete_at_beginning(self):
    if self.head.next:
        self.head = self.head.next
    else:
        self.head = None

A AttributeError when list is empty

B No error, works correctly

C TypeError when list is empty

D IndexError when list has multiple nodes

💡 Hint

Check what happens if head is None before accessing head.next.

If the list is empty (head is None), accessing head.next causes AttributeError. The code does not check if head is None before accessing head.next.

🧠 Conceptual

advanced

What is the time complexity of deleting the first node in a singly linked list?

Consider a singly linked list with n nodes. What is the time complexity of deleting the node at the beginning?

A O(1)

B O(n)

C O(log n)

D O(n^2)

💡 Hint

Deleting the first node only changes the head pointer.

Deleting the first node requires only updating the head pointer to the next node, which is a constant time operation.

🚀 Application

expert

After multiple deletions at beginning, what is the list state?

Starting with the list 1 -> 2 -> 3 -> 4 -> 5 -> null, after deleting the first node three times, what is the printed list?

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_at_beginning(self):
        if self.head:
            self.head = self.head.next

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

ll = LinkedList()
for i in range(1, 6):
    ll.append(i)
ll.delete_at_beginning()
ll.delete_at_beginning()
ll.delete_at_beginning()
ll.print_list()

A 2 -> 3 -> 4 -> 5 -> null

B 3 -> 4 -> 5 -> null

C null

D 4 -> 5 -> null

💡 Hint

Each deletion removes the current head node.

Deleting three times removes nodes 1, 2, and 3. The new head is node 4, so the list is 4 -> 5 -> null.