Push Using Linked List Node in DSA Python - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output after pushing nodes in this linked list?

Consider the following Python code that pushes nodes to the front of a linked list. What will be the printed linked list after all push operations?

DSA Python

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

class LinkedList:
    def __init__(self):
        self.head = None

    def push(self, new_data):
        new_node = Node(new_data)
        new_node.next = self.head
        self.head = new_node

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

llist = LinkedList()
llist.push(10)
llist.push(20)
llist.push(30)
llist.printList()

A 30 -> 10 -> 20 -> null

B 10 -> 20 -> 30 -> null

C null -> 30 -> 20 -> 10

D 30 -> 20 -> 10 -> null

💡 Hint

Remember, push adds a new node at the front of the list.

Each push adds a new node at the beginning. So the last pushed node (30) becomes the head, followed by 20, then 10.

❓ Predict Output

intermediate

What is the linked list after these push operations?

Given this code snippet, what will be the final linked list printed?

DSA Python

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

class LinkedList:
    def __init__(self):
        self.head = None

    def push(self, new_data):
        new_node = Node(new_data)
        new_node.next = self.head
        self.head = new_node

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

llist = LinkedList()
llist.push(5)
llist.push(15)
llist.push(25)
llist.push(35)
llist.printList()

A 5 -> 15 -> 25 -> 35 -> null

B 35 -> 25 -> 15 -> 5 -> null

C null -> 5 -> 15 -> 25 -> 35

D 15 -> 5 -> 25 -> 35 -> null

💡 Hint

New nodes are added at the front, so the last pushed node is the head.

Push adds nodes at the front, so the list order is reversed from the push order.

🔧 Debug

advanced

Why does this push method cause an error?

Look at this push method in a linked list class. It causes an error when called. What is the cause?

DSA Python

def push(self, new_data):
    new_node = Node(new_data)
    new_node.next = self.head.next
    self.head = new_node

A self.head might be None, so self.head.next causes AttributeError

B The method does not assign new_node.data correctly

C new_node.next should be None, not self.head.next

D self.head is not updated properly to new_node

💡 Hint

Think about what happens if the list is empty before push.

If the list is empty, self.head is None. Accessing self.head.next causes an error because None has no attribute 'next'.

❓ Predict Output

advanced

What is the linked list after pushing nodes with these values?

Given the following code, what will be the printed linked list?

DSA Python

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

class LinkedList:
    def __init__(self):
        self.head = None

    def push(self, new_data):
        new_node = Node(new_data)
        new_node.next = self.head
        self.head = new_node

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

llist = LinkedList()
for value in [1, 2, 3, 4, 5]:
    llist.push(value)
llist.printList()

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

B 1 -> 2 -> 3 -> 4 -> 5 -> null

C null -> 1 -> 2 -> 3 -> 4 -> 5

D 5 -> 3 -> 1 -> 2 -> 4 -> null

💡 Hint

Push adds each new node at the front, reversing the order.

The last pushed value (5) becomes the head, so the list is reversed from the input order.

🧠 Conceptual

expert

What is the time complexity of pushing a node at the front of a linked list?

Consider a singly linked list. What is the time complexity of the push operation that adds a node at the front?

A O(n^2) - Quadratic time

B O(n) - Linear time

C O(1) - Constant time

D O(log n) - Logarithmic time

💡 Hint

Think about how many nodes you need to visit to add at the front.

Adding a node at the front only changes the head pointer and the new node's next pointer, which takes constant time.