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

Challenge - 5 Problems

🧠 Conceptual

intermediate

Why do we use a stack in function calls?

Imagine you have multiple functions calling each other. Why is a stack the best data structure to keep track of these calls?

A Because a stack follows Last In First Out, so the most recent function call is completed before returning to the previous one.

B Because a stack stores all function calls in random order for quick access.

C Because a stack allows skipping some function calls and jumping to others directly.

D Because a stack stores function calls permanently without removing them.

💡 Hint

Think about how functions return in the reverse order of how they were called.

A stack works like a pile of plates: the last plate placed on top is the first one to be taken off. Similarly, the last function called must finish before the previous one continues. This Last In First Out behavior perfectly matches how function calls are managed.

❓ Predict Output

intermediate

Output of Stack Operations

What is the printed output after performing these stack operations in Java?

DSA Java

import java.util.Stack;
public class StackTest {
  public static void main(String[] args) {
    Stack<Integer> stack = new Stack<>();
    stack.push(10);
    stack.push(20);
    stack.push(30);
    System.out.print(stack.pop() + " -> ");
    System.out.print(stack.peek() + " -> ");
    System.out.print(stack.pop() + " -> ");
    System.out.print(stack.pop());
  }
}

A 10 -> 30 -> 20 -> 10

B 10 -> 20 -> 30 -> 20

C 30 -> 20 -> 20 -> 10

D 30 -> 30 -> 20 -> 10

💡 Hint

Remember that pop() removes and returns the top element, while peek() only returns the top element without removing it.

The stack after pushes is [10, 20, 30] (30 on top). pop() removes 30, prints it. peek() shows 20. pop() removes 20, prints it. pop() removes 10, prints it.

🔧 Debug

advanced

Identify the problem in stack usage

What error will this Java code produce when run?

DSA Java

import java.util.Stack;
public class StackError {
  public static void main(String[] args) {
    Stack<String> stack = new Stack<>();
    stack.push("apple");
    stack.pop();
    stack.pop();
  }
}

A NullPointerException at second pop()

B EmptyStackException at second pop()

C No error, prints nothing

D ArrayIndexOutOfBoundsException at second pop()

💡 Hint

What happens if you try to remove an element from an empty stack?

After the first pop(), the stack is empty. The second pop() tries to remove an element from an empty stack, causing an EmptyStackException.

🚀 Application

advanced

Using stack to check balanced parentheses

Which option correctly uses a stack to check if parentheses in a string are balanced?

DSA Java

public boolean isBalanced(String s) {
  Stack<Character> stack = new Stack<>();
  for (char c : s.toCharArray()) {
    if (c == '(') {
      stack.push(c);
    } else if (c == ')') {
      if (stack.isEmpty()) return false;
      stack.pop();
    }
  }
  return stack.isEmpty();
}

A Always returns true regardless of input.

B Returns true if string contains any parentheses, false otherwise.

C Returns false if string contains no parentheses, true otherwise.

D Returns true if all '(' have matching ')' in correct order, false otherwise.

💡 Hint

Think about how the stack helps track opening parentheses and matches them with closing ones.

The stack stores '(' characters. For each ')', it removes one '(' from the stack. If at the end the stack is empty, all parentheses matched correctly.

🧠 Conceptual

expert

Why is stack preferred over queue for undo operations?

In applications like text editors, undo operations are common. Why is a stack better than a queue to implement undo functionality?

A Because undo needs to reverse the most recent action first, which matches stack's Last In First Out behavior.

B Because queue allows undoing actions in the order they were done, which is preferred.

C Because queue is slower than stack for storing actions.

D Because stack stores all actions permanently, while queue deletes them immediately.

💡 Hint

Think about which action should be undone first: the last one or the first one?

Undo operations must reverse the last action first, so the Last In First Out order of a stack fits perfectly. A queue would undo actions in the order they were done, which is incorrect for undo.

Practice

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

easy

A. To store large amounts of data permanently

B. To store data in random order

C. To sort numbers automatically

D. To keep track of function calls and return addresses

Solution

1. Step 1: Understand the role of stack in function calls

   Stacks help keep track of where each function should return after finishing execution, storing return addresses in order.

2. Step 2: Compare other options

   Stacks do not sort data automatically, nor store data randomly or permanently; their main use is managing function calls.

3. Final Answer:

   To keep track of function calls and return addresses -> Option D

4. Quick Check:

   Stack manages function calls = A [OK]

Hint: Stack remembers last task first, like a pile of plates [OK]

Common Mistakes:

• Thinking stack sorts data automatically
• Confusing stack with permanent storage
• Assuming stack stores data randomly

2. Which of the following is the correct way to push an element onto a stack in Java?

easy

A. stack.push(element);

B. stack.put(element);

C. stack.insert(element);

D. stack.add(element);

Solution

1. Step 1: Recall Java Stack method names

   The Java Stack class uses the method push() to add elements on top of the stack.

2. Step 2: Check other method names

   Methods like add(), insert(), or put() are not standard for Stack push operation in Java.

3. Final Answer:

   stack.push(element); -> Option A

4. Quick Check:

   Push method adds element = D [OK]

Hint: Use push() to add on top of stack in Java [OK]

Common Mistakes:

• Using add() instead of push()
• Confusing insert() with push()
• Using put() which is not a Stack method

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

Stack<Integer> stack = new Stack<>();
stack.push(10);
stack.push(20);
stack.push(30);
System.out.println(stack.pop());
System.out.println(stack.peek());

medium

A. 20
30

B. 10
20

C. 30
20

D. 30
10

Solution

1. Step 1: Trace push operations

   Elements pushed in order: 10 (bottom), 20, 30 (top).

2. Step 2: Trace pop and peek

   pop() removes and returns top element 30; peek() returns new top element 20 without removing it.

3. Final Answer:

   30 20 -> Option C

4. Quick Check:

   pop()=30, peek()=20 [OK]

Hint: pop() removes top, peek() shows top without removing [OK]

Common Mistakes:

• Confusing pop() and peek() results
• Assuming pop() returns bottom element
• Mixing order of pushed elements

4. Identify the error in the following Java code using Stack:

Stack<String> stack = new Stack<>();
stack.push("A");
stack.push("B");
System.out.println(stack.pop());
System.out.println(stack.pop());
System.out.println(stack.pop());

medium

A. Stack underflow error at third pop()

B. No error, code runs fine

C. Syntax error in stack declaration

D. push() method is incorrect

Solution

1. Step 1: Count push and pop operations

   Two elements pushed: "A", "B"; three pop() calls made.

2. Step 2: Analyze pop() calls

   First two pop() calls remove "B" and "A"; third pop() tries to remove from empty stack causing underflow error.

3. Final Answer:

   Stack underflow error at third pop() -> Option A

4. Quick Check:

   More pops than pushes = underflow error [OK]

Hint: Pop more times than push causes error [OK]

Common Mistakes:

• Ignoring stack underflow on extra pop()
• Thinking push() syntax is wrong
• Assuming no error occurs

5. You want to reverse a string using a stack in Java. Which sequence of operations correctly achieves this?

hard

A. Push all characters, then push again to reverse

B. Push each character, then pop all to build reversed string

C. Pop each character, then push all to build reversed string

D. Peek each character, then pop all to build reversed string

Solution

1. Step 1: Understand stack reversal logic

   Pushing characters stores them in order; popping them reverses order because stack is last-in-first-out.

2. Step 2: Evaluate options

   Only pushing then popping all characters correctly reverses the string; popping before pushing or peeking does not reverse.

3. Final Answer:

   Push each character, then pop all to build reversed string -> Option B

4. Quick Check:

   Push then pop reverses string = C [OK]

Hint: Push all, then pop all to reverse order [OK]

Common Mistakes:

• Trying to pop before pushing
• Using peek instead of pop to build reversed string
• Pushing twice without popping