Min Stack Design in DSA Typescript - 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 seen so far. When pushing, it compares the new value with the current minimum and updates the auxiliary stack accordingly.

beginner

TypeScript method signature: How do you define a push method for a Min Stack?

push(val: number): void - This method adds a value to the stack and updates the minimum stack if needed.

intermediate

Why do we need to push the minimum value again on the min stack when the new value is equal to the current minimum?

Because multiple elements can have the same minimum value, pushing duplicates ensures the min stack correctly tracks the minimum after popping elements.

beginner

What is the time complexity of getMin operation in a Min Stack?

The getMin operation runs in O(1) time because it returns the top element of the auxiliary min stack without any traversal.

What does the auxiliary stack in a Min Stack store?

A Minimum values seen so far

B All values pushed

C Maximum values seen so far

D Only the top element

The auxiliary stack stores the minimum values seen so far to allow constant time retrieval of the minimum.

When pushing a new value, when do you push it onto the min stack?

A Only if it is greater than the current minimum

B Always

C Never

D Only if it is less than or equal to the current minimum

You push the new value onto the min stack only if it is less than or equal to the current minimum to keep track of minimums.

What happens to the min stack when you pop the main stack?

A Always pop from min stack

B Pop from min stack if the popped value equals the min stack's top

C Never pop from min stack

D Clear the min stack

You pop from the min stack only if the popped value from the main stack equals the current minimum.

What is the time complexity of push, pop, and getMin in a Min Stack?

A O(n) for all

B O(n) for push, O(1) for pop and getMin

C O(1) for all

D O(1) for push and pop, O(n) for getMin

All operations push, pop, and getMin run in constant time O(1) in a Min Stack.

Why is it important to handle duplicate minimum values in a Min Stack?

A To correctly update minimum after popping duplicates

B To save memory

C To speed up push operation

D It is not important

Handling duplicates ensures the minimum is correctly updated after popping elements with the same minimum value.

Explain how a Min Stack works and how it keeps track of the minimum element efficiently.

Think about how to remember the smallest number at every step.

Describe the steps to implement push, pop, and getMin methods in a Min Stack.

Focus on how both stacks change during each operation.

Practice

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

easy

A. To retrieve the minimum element in constant time

B. To sort elements automatically

C. To store elements in ascending order

D. To remove duplicates from the stack

Solution

1. Step 1: Understand the Min Stack functionality

   A Min Stack is designed to keep track of the minimum element efficiently while supporting normal stack operations.

2. Step 2: Identify the key feature

   The key feature is retrieving the minimum element in constant time, which normal stacks cannot do efficiently.

3. Final Answer:

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

4. Quick Check:

   Min Stack = constant time minimum retrieval [OK]

Hint: Min Stack always gives min element fast [OK]

Common Mistakes:

• Thinking it sorts elements automatically
• Confusing with normal stack behavior
• Assuming it removes duplicates

2. Which of the following is the correct TypeScript method signature to push an element x onto a Min Stack class?

easy

A. push(x: number): number

B. push(x: string): number

C. push(x: number): void

D. push(): number

Solution

1. Step 1: Understand push method requirements

   The push method should accept a number and return nothing (void) because it adds an element to the stack.

2. Step 2: Match method signature

   push(x: number): void matches: it takes a number and returns void, which is correct for push operation.

3. Final Answer:

   push(x: number): void -> Option C

4. Quick Check:

   Push method signature = push(x: number): void [OK]

Hint: Push takes number, returns void in stack [OK]

Common Mistakes:

• Using wrong parameter type like string
• Returning number instead of void
• Missing parameter in method

3. Consider the following TypeScript code for a Min Stack:

const minStack = new MinStack();
minStack.push(3);
minStack.push(5);
minStack.push(2);
minStack.push(1);
minStack.pop();
const min = minStack.getMin();
console.log(min);

What will be printed?

medium

A. 2

B. 1

C. 3

D. 5

Solution

1. Step 1: Trace push and pop operations

   Push 3, 5, 2, 1 onto stack. Stack is [3,5,2,1]. Then pop removes 1. Stack is now [3,5,2].

2. Step 2: Find minimum after pop

   Minimum among [3,5,2] is 2, so getMin() returns 2.

3. Final Answer:

   2 -> Option A

4. Quick Check:

   Min after pop = 2 [OK]

Hint: Pop removes top; min updates accordingly [OK]

Common Mistakes:

• Forgetting pop removes last pushed element
• Assuming min stays 1 after pop
• Confusing stack order

4. The following TypeScript Min Stack implementation has a bug. What is the error?

class MinStack {
  stack: number[] = [];
  minStack: number[] = [];

  push(x: number): void {
    this.stack.push(x);
    if (this.minStack.length === 0 || x <= this.minStack[this.minStack.length - 1]) {
      this.minStack.push(x);
    }
  }

  pop(): void {
    const val = this.stack.pop();
    if (val === this.minStack[this.minStack.length - 1]) {
      this.minStack.pop();
    }
  }

  getMin(): number {
    return this.minStack[this.minStack.length - 1];
  }
}

medium

A. push() pushes to minStack even if x > current min

B. pop() does not handle empty stack case

C. getMin() returns wrong element index

D. stack array is not initialized

Solution

1. Step 1: Analyze pop() method

   pop() calls this.stack.pop() which can return undefined if stack is empty, then compares with minStack top without check.

2. Step 2: Identify missing empty check

   There is no check if stack is empty before pop, so val can be undefined causing incorrect comparison or error.

3. Final Answer:

   pop() does not handle empty stack case -> Option B

4. Quick Check:

   pop() missing empty check = bug [OK]

Hint: Always check stack empty before pop [OK]

Common Mistakes:

• Ignoring empty stack before pop
• Assuming push always pushes to minStack
• Misreading getMin index

5. You want to design a Min Stack that supports push, pop, top, and getMin all in constant time. Which approach below correctly achieves this?

hard

A. Use one stack and scan all elements to find min on getMin

B. Use a queue to store elements and find min by sorting

C. Use a linked list and traverse to find min on getMin

D. Use two stacks: one for all elements, one for current mins

Solution

1. Step 1: Understand time complexity requirements

   All operations must be constant time, so scanning or traversing is not allowed.

2. Step 2: Identify data structure approach

   Using two stacks, one for elements and one for tracking minimums, allows constant time push, pop, and getMin.

3. Final Answer:

   Use two stacks: one for all elements, one for current mins -> Option D

4. Quick Check:

   Two stacks = constant time min tracking [OK]

Hint: Two stacks track elements and mins fast [OK]

Common Mistakes:

• Using scanning which is not constant time
• Using queue which is not stack
• Using linked list traversal for min