Min Stack Design in DSA C++ - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the main purpose of a Min Stack?

A Min Stack is a special stack that supports retrieving the minimum element in constant time, along with normal stack operations like push and pop.

intermediate

How does a Min Stack keep track of the minimum element efficiently?

It uses an auxiliary stack to store the minimum values at each state, so the current minimum can be retrieved in O(1) time.

beginner

In Min Stack design, what happens when you push a new element smaller than the current minimum?

You push the new element onto the main stack and also push it onto the min stack because it becomes the new minimum.

beginner

What is the time complexity of retrieving the minimum element from a Min Stack?

The time complexity is O(1), meaning it takes constant time regardless of the stack size.

intermediate

Why do we pop from the min stack when popping from the main stack in a Min Stack?

Because the minimum might change after popping, so we remove the top of the min stack to keep it in sync with the main stack's state.

What extra data structure is commonly used in Min Stack design to track minimum values?

A Hash map

B Queue

C Auxiliary stack

D Linked list

An auxiliary stack is used to keep track of minimum values at each state.

What is the time complexity to get the minimum element from a Min Stack?

A O(n)

B O(1)

C O(n log n)

D O(log n)

Retrieving the minimum element is done in constant time O(1).

When pushing a new element equal to the current minimum, what should happen in the min stack?

A Do not push it to the min stack

B Clear the min stack

C Replace the min stack top

D Push it to the min stack

Push the new element to the min stack to keep track of duplicates of the minimum.

What happens to the min stack when popping the top element from the main stack?

A Pop the top element from the min stack if it equals the popped element

B Do nothing to the min stack

C Push a new minimum to the min stack

D Clear the min stack

Pop from the min stack only if the popped element is the current minimum.

Which operation is NOT supported by a Min Stack?

A search arbitrary element

B push

C getMin

D pop

Min Stack does not support searching arbitrary elements efficiently.

Explain how a Min Stack maintains the minimum element during push and pop operations.

Think about how two stacks work together to track minimum.

Describe the steps to implement a Min Stack with O(1) time for push, pop, and getMin.

Focus on how to keep min stack synchronized with main stack.

Practice

1. What is the main purpose of a Min Stack data structure?

easy

A. To store elements in a queue fashion

B. To retrieve the minimum element in constant time

C. To sort elements in ascending order

D. To reverse the order of elements

Solution

1. Step 1: Understand the Min Stack concept

   A Min Stack is designed to keep track of the minimum element efficiently.

2. Step 2: Identify the key feature

   It allows retrieving the minimum element in constant time, unlike a normal stack.

3. Final Answer:

   To retrieve the minimum element in constant time -> Option B

4. Quick Check:

   Min Stack purpose = retrieve minimum element fast [OK]

Hint: Min Stack always tracks minimum for O(1) retrieval [OK]

Common Mistakes:

• Confusing Min Stack with sorting
• Thinking it behaves like a queue
• Assuming it reverses elements

2. Which of the following is the correct way to declare a stack of integers in C++?

easy

A. stack<int> s[];

B. stack s<int>;

C. stack<int> s;

D. stack<int> s()

Solution

1. Step 1: Recall C++ stack declaration syntax

   The correct syntax uses template with angle brackets and variable name after.

2. Step 2: Check each option

   stack<int> s; matches correct syntax: stack<int> s;. Others have syntax errors.

3. Final Answer:

   stack<int> s; -> Option C

4. Quick Check:

   C++ stack declaration = stack<int> s; [OK]

Hint: Use template syntax: stack<Type> variable; [OK]

Common Mistakes:

• Placing variable name inside angle brackets
• Using parentheses instead of semicolon
• Declaring as array without initialization

3. Consider the following C++ code snippet implementing a Min Stack push operation:

void push(int x) {
  s.push(x);
  if (minStack.empty() || x <= minStack.top()) {
    minStack.push(x);
  }
}

What will be the content of minStack after pushing the sequence [3, 5, 2, 2, 4]?

medium

A. [3, 5, 2, 2, 4]

B. [2, 2]

C. [3, 2]

D. [3, 2, 2]

Solution

1. Step 1: Trace push operations on minStack

   Push 3: minStack empty, push 3 -> [3] Push 5: 5 > top(3), no push -> [3] Push 2: 2 <= 3, push 2 -> [3, 2] Push 2: 2 <= 2, push 2 -> [3, 2, 2] Push 4: 4 > 2, no push -> [3, 2, 2]

2. Step 2: Confirm final minStack content

   minStack contains [3, 2, 2] after all pushes.

3. Final Answer:

   [3, 2, 2] -> Option D

4. Quick Check:

   minStack after pushes = [3, 2, 2] [OK]

Hint: Push to minStack only if new value ≤ current min [OK]

Common Mistakes:

• Pushing all elements to minStack
• Not pushing duplicates of min
• Confusing minStack with main stack

4. The following code snippet is intended to implement the pop() operation of a Min Stack. Identify the error:

void pop() {
  if (s.top() == minStack.top()) {
    minStack.pop();
  }
  s.pop();
}

medium

A. It does not check if stacks are empty before popping

B. It pops from minStack before popping from s, causing mismatch

C. It compares values incorrectly using == instead of <=

D. It should pop from s twice when values match

Solution

1. Step 1: Analyze pop operation safety

   The code pops from stacks without checking if they are empty, risking runtime errors.

2. Step 2: Identify missing safety checks

   Before calling top() or pop(), stacks should be checked for emptiness.

3. Final Answer:

   It does not check if stacks are empty before popping -> Option A

4. Quick Check:

   Pop safety requires empty checks [OK]

Hint: Always check stack empty before pop or top [OK]

Common Mistakes:

• Ignoring empty stack checks
• Misusing comparison operators
• Popping stacks in wrong order

5. You want to design a Min Stack that supports push, pop, top, and getMin all in O(1) time. Which approach below correctly achieves this with minimal extra space?

hard

A. Use one stack to store values and a second stack to store minimums only when a new minimum is pushed

B. Use one stack and sort it after each push to find minimum

C. Use two stacks: one for values and one for all values pushed, then find min by scanning

D. Use a queue to store values and a stack to store minimums

Solution

1. Step 1: Understand O(1) min retrieval requirement

   To get minimum in constant time, we must track minimums during push/pop without scanning.

2. Step 2: Evaluate approaches

   Use one stack to store values and a second stack to store minimums only when a new minimum is pushed uses a second stack to store minimums only when a new minimum appears, saving space and ensuring O(1) operations.

3. Final Answer:

   Use one stack to store values and a second stack to store minimums only when a new minimum is pushed -> Option A

4. Quick Check:

   Min Stack with minimal space = two stacks, min pushed selectively [OK]

Hint: Push min only when new min found to save space [OK]

Common Mistakes:

• Sorting stack after each push (slow)
• Scanning stack to find min (not O(1))
• Using queue which breaks stack order