Stack Implementation Using Linked List in DSA Python - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output after these stack operations?

Consider a stack implemented using a linked list. The following operations are performed in order:

1. push(10)
2. push(20)
3. pop()
4. push(30)
5. pop()
6. push(40)

What is the printed state of the stack from top to bottom?

DSA Python

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

class Stack:
    def __init__(self):
        self.top = None

    def push(self, data):
        new_node = Node(data)
        new_node.next = self.top
        self.top = new_node

    def pop(self):
        if self.top is None:
            return None
        popped = self.top.data
        self.top = self.top.next
        return popped

    def print_stack(self):
        current = self.top
        result = []
        while current:
            result.append(str(current.data))
            current = current.next
        print(" -> ".join(result) + " -> null")

stack = Stack()
stack.push(10)
stack.push(20)
stack.pop()
stack.push(30)
stack.pop()
stack.push(40)
stack.print_stack()

A 40 -> 10 -> null

B 20 -> 10 -> null

C 30 -> 10 -> null

D 10 -> 40 -> null

💡 Hint

Remember that push adds to the top and pop removes from the top.

After the operations, the stack top is 40, then 10 below it, then null.

❓ Predict Output

intermediate

What error occurs when popping from an empty stack?

Given the stack implementation below, what happens if we call pop() on an empty stack?

DSA Python

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

class Stack:
    def __init__(self):
        self.top = None

    def pop(self):
        if self.top is None:
            return None
        popped = self.top.data
        self.top = self.top.next
        return popped

stack = Stack()
print(stack.pop())

A TypeError

B None

C AttributeError

D IndexError

💡 Hint

Check the condition when the stack is empty before popping.

The pop method returns None if the stack is empty, so no error occurs.

🔧 Debug

advanced

Identify the bug in this push method

Look at the push method below. What is the bug that will cause incorrect stack behavior?

DSA Python

def push(self, data):
    new_node = Node(data)
    if self.top is None:
        self.top = new_node
    else:
        self.top.next = new_node
        self.top = new_node

A The new node is added at the bottom instead of the top

B The top pointer is not updated correctly

C The next pointer of the new node is not set to the current top

D The method does not create a new node

💡 Hint

Remember the linked list stack adds new nodes at the front.

The new node's next pointer must point to the current top node before updating top.

🚀 Application

advanced

How many elements remain after these operations?

Starting with an empty stack, perform these operations:

1. push(5)
2. push(15)
3. pop()
4. push(25)
5. push(35)
6. pop()
7. pop()

How many elements remain in the stack?

DSA Python

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

class Stack:
    def __init__(self):
        self.top = None

    def push(self, data):
        new_node = Node(data)
        new_node.next = self.top
        self.top = new_node

    def pop(self):
        if self.top is None:
            return None
        popped = self.top.data
        self.top = self.top.next
        return popped

    def size(self):
        count = 0
        current = self.top
        while current:
            count += 1
            current = current.next
        return count

stack = Stack()
stack.push(5)
stack.push(15)
stack.pop()
stack.push(25)
stack.push(35)
stack.pop()
stack.pop()
print(stack.size())

A 0

B 2

C 3

D 1

💡 Hint

Count pushes and pops carefully.

After all operations, only one element remains in the stack.

🧠 Conceptual

expert

Why is linked list preferred over array for stack in some cases?

Which reason best explains why a linked list implementation of a stack might be preferred over an array implementation?

A Linked list allows dynamic size without resizing overhead

B Linked list uses less memory than arrays always

C Linked list provides faster access to middle elements

D Linked list requires less code to implement than arrays

💡 Hint

Think about how arrays handle size changes.

Linked lists grow dynamically without needing to resize, unlike arrays which may need costly resizing.