Why Stack Exists and What Problems It Solves in DSA Python - Challenge Your Understanding

Challenge - 5 Problems

🧠 Conceptual

intermediate

Why do we use a stack in function calls?

Imagine you are cooking multiple dishes, and you need to remember which step to return to after finishing a sub-step. Which of these best explains why a stack is used in managing function calls in programming?

A Because a stack deletes all previous function calls immediately after a new call is made.

B Because a stack allows random access to any function call at any time.

C Because a stack remembers the last function called and returns to it first, like a stack of plates where you take the top plate first.

D Because a stack stores all function calls in a queue to process them in the order they were called.

💡 Hint

Think about how you would keep track of tasks that depend on finishing other tasks first.

A stack follows Last In First Out (LIFO) order, which matches how function calls return: the last function called must finish before returning to the previous one.

❓ Predict Output

intermediate

Output of Stack Operations

What is the printed output after running this Python code that uses a stack to reverse a list?

DSA Python

stack = []
items = [1, 2, 3, 4]
for item in items:
    stack.append(item)
reversed_list = []
while stack:
    reversed_list.append(stack.pop())
print(reversed_list)

A [4, 3, 2, 1]

B [1, 2, 3, 4]

C [1, 4, 2, 3]

D []

💡 Hint

Think about what happens when you add items to a stack and then remove them.

The stack stores items in order, but popping removes the last added item first, reversing the list.

🔧 Debug

advanced

Identify the Error in Stack Usage

This code tries to check if parentheses in a string are balanced using a stack. What error will it raise when run?

DSA Python

def check_parentheses(s):
    stack = []
    for char in s:
        if char == '(': 
            stack.append(char)
        elif char == ')':
            stack.pop()
    return len(stack) == 0

print(check_parentheses('())'))

A Returns False

B SyntaxError: invalid syntax

C Returns True

D IndexError: pop from empty list

💡 Hint

What happens if you try to pop from an empty stack?

If the string has more closing parentheses than opening ones, popping from an empty stack causes an IndexError.

🚀 Application

advanced

Using Stack to Evaluate Postfix Expression

Given the postfix expression '3 4 + 2 * 7 /', what is the final result after evaluating it using a stack?

A 2.0

B 14

C 1.0

D 7

💡 Hint

Evaluate step-by-step: push numbers, pop two for operation, push result back.

Postfix evaluation uses a stack to compute operations in order. The expression evaluates to 2.0.

🧠 Conceptual

expert

Why is Stack Preferred for Undo Operations?

In text editors, undo operations are often implemented using a stack. Why is a stack the best choice for this?

A Because stacks allow undoing actions in any random order.

B Because the last action performed should be the first one undone, matching the stack's Last In First Out behavior.

C Because stacks store all actions permanently without removing any.

D Because stacks process actions in the order they were first performed.

💡 Hint

Think about which action you want to undo first.

Undoing requires reversing the most recent action first, which fits the LIFO nature of stacks.

Practice

1. Why do we use a stack data structure in programming?

easy

A. To sort numbers automatically

B. To keep track of function calls and return in the correct order

C. To store data in random order for quick access

D. To store data permanently on disk

Solution

1. Step 1: Understand the nature of stack

   A stack works on Last In First Out (LIFO) principle, meaning the last item added is the first to be removed.

2. Step 2: Relate stack to function calls

   Function calls are nested and must return in reverse order of calling, which matches LIFO behavior of stack.

3. Final Answer:

   To keep track of function calls and return in the correct order -> Option B

4. Quick Check:

   Stack = Function call tracking [OK]

Hint: Stack follows LIFO, perfect for tracking nested calls [OK]

Common Mistakes:

• Thinking stack sorts data automatically
• Confusing stack with queue (FIFO)
• Assuming stack stores data permanently

2. Which of the following is the correct way to push an element 'x' onto a stack named stack in Python?

easy

A. stack.push(x)

B. stack.add(x)

C. stack.append(x)

D. stack.insert(x)

Solution

1. Step 1: Recall Python list methods for stack

   Python uses list to implement stack; append() adds element to the top.

2. Step 2: Check other options

   push() and add() are not list methods; insert() inserts at specific index, not top.

3. Final Answer:

   stack.append(x) -> Option C

4. Quick Check:

   Use append() to push in Python stack [OK]

Hint: Use append() to add on top of Python list stack [OK]

Common Mistakes:

• Using push() which is not a Python list method
• Using insert() without index argument
• Confusing add() with append()

3. What will be the output of the following Python code?

stack = []
stack.append(1)
stack.append(2)
stack.append(3)
print(stack.pop())
print(stack)

medium

A. 3
[1, 2]

B. 1
[2, 3]

C. 2
[1, 3]

D. 3
[3, 2, 1]

Solution

1. Step 1: Trace stack after append operations

   After appending 1, 2, 3, stack = [1, 2, 3]

2. Step 2: Understand pop() behavior

   pop() removes and returns last element, so pop() returns 3 and stack becomes [1, 2]

3. Final Answer:

   3 [1, 2] -> Option A

4. Quick Check:

   pop() returns last item, stack updates [OK]

Hint: pop() removes last added element in stack [OK]

Common Mistakes:

• Thinking pop() removes first element
• Confusing append() with insert()
• Expecting stack to be unchanged after pop()

4. The following code is intended to reverse a list using a stack, but it has an error. What is the error?

def reverse_list(lst):
    stack = []
    for item in lst:
        stack.push(item)
    reversed_lst = []
    while stack:
        reversed_lst.append(stack.pop())
    return reversed_lst

print(reverse_list([1, 2, 3]))

medium

A. Using push() method which does not exist for Python lists

B. Using pop() incorrectly without parentheses

C. Not initializing reversed_lst before use

D. Loop condition should be 'while not stack'

Solution

1. Step 1: Check stack operations in Python

   Python lists do not have push() method; append() should be used to add elements.

2. Step 2: Verify other parts of code

   pop() is used correctly with parentheses; reversed_lst is initialized; while stack is correct to check non-empty list.

3. Final Answer:

   Using push() method which does not exist for Python lists -> Option A

4. Quick Check:

   Use append() not push() for Python list stack [OK]

Hint: Python list uses append(), not push() [OK]

Common Mistakes:

• Using push() instead of append()
• Forgetting parentheses on pop()
• Incorrect while loop condition

5. You want to check if a string has balanced parentheses using a stack. Which approach correctly solves this problem?

hard

A. Use a queue to enqueue '(' and dequeue when ')' found

B. Count total '(' and ')' characters; if counts equal, parentheses are balanced

C. Replace all '(' with ')' and check if string is palindrome

D. Push '(' onto stack; pop when ')' found; if stack empty at end, parentheses are balanced

Solution

1. Step 1: Understand balanced parentheses logic

   Each '(' must be matched by a ')' in correct order; stack helps track unmatched '('.

2. Step 2: Explain stack approach

   Push '(' onto stack; on encountering ')', pop stack; if stack empty at end, parentheses are balanced.

3. Step 3: Evaluate other options

   Counting characters ignores order; palindrome check is unrelated; queue (FIFO) does not match nesting order.

4. Final Answer:

   Push '(' onto stack; pop when ')' found; if stack empty at end, parentheses are balanced -> Option D

5. Quick Check:

   Stack tracks open parentheses for balance [OK]

Hint: Use stack push/pop to match parentheses pairs [OK]

Common Mistakes:

• Only counting parentheses without order check
• Using queue instead of stack for nesting
• Ignoring unmatched parentheses inside string