Min Stack - Practice Coding Problems

Min Stack - Problem

Stack Design Medium

Imagine you're building a smart stack that not only stores elements but also instantly knows its minimum value at all times! This is more challenging than it sounds because stacks only allow access to the top element.

Your task is to design a MinStack class that supports these operations:

push(val) - Add an element to the top
pop() - Remove the top element
top() - Get the top element
getMin() - Get the minimum element

The catch? All operations must run in O(1) constant time! No scanning through the entire stack allowed.

Example:

MinStack minStack = new MinStack();
minStack.push(-2);
minStack.push(0);
minStack.push(-3);
minStack.getMin(); // return -3
minStack.pop();
minStack.top();    // return 0
minStack.getMin(); // return -2

Input & Output

example_1.py — Basic Operations

$ Input: ["MinStack","push","push","push","getMin","pop","top","getMin"] [[],[-2],[0],[-3],[],[],[],[]]

› Output: [null,null,null,null,-3,null,0,-2]

💡 Note: MinStack minStack = new MinStack(); minStack.push(-2); minStack.push(0); minStack.push(-3); minStack.getMin(); // return -3; minStack.pop(); minStack.top(); // return 0; minStack.getMin(); // return -2

example_2.py — Duplicate Minimums

$ Input: ["MinStack","push","push","push","getMin","pop","getMin"] [[],[1],[1],[1],[],[],[]]

› Output: [null,null,null,null,1,null,1]

💡 Note: When all elements are the same, the minimum remains constant. After popping one element, the minimum is still 1.

example_3.py — Ascending Order

$ Input: ["MinStack","push","push","push","getMin","pop","getMin","pop","getMin"] [[],[3],[2],[1],[],[],[],[],[]]

› Output: [null,null,null,null,1,null,2,null,3]

💡 Note: Elements pushed in descending order. Each pop operation reveals the next minimum in the remaining stack.

Constraints

-2³¹ <= val <= 2³¹ - 1
Methods pop, top and getMin operations will always be called on non-empty stacks
At most 3 × 10⁴ calls will be made to push, pop, top, and getMin

Visualization

Tap to expand

Understanding the Visualization

Smart Labeling

Each plate gets a smart label showing the most valuable plate up to that point

Adding Plates

When adding a new plate, compare its value with the current most valuable and update the label

Instant Access

The waiter can instantly see the most valuable plate by reading the top label

Removing Plates

When plates are removed, the labels automatically reveal the next most valuable plate

Key Takeaway

🎯 Key Insight: By maintaining minimum information at each stack level, we eliminate the need to search through all elements, achieving O(1) performance for all operations.

Asked in

a Amazon 45 G Google 38 ⊞ Microsoft 32 f Meta 28

The optimal solution uses two stacks: a main stack for elements and an auxiliary stack for tracking minimums. This achieves O(1) time complexity for all operations by maintaining the minimum value at each stack level, allowing instant minimum retrieval without scanning.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Linear Scan)	O(n)	O(1)	Use a regular stack and scan all elements to find minimum
Two Stack Approach (Optimal)	O(1)	O(n)	Use two stacks: one for elements, one for tracking minimums

Brute Force (Linear Scan) — Algorithm Steps

Use a simple list/array as stack for push, pop, top operations
For getMin(), scan through entire stack to find minimum
Return the minimum value found

Visualization

Tap to expand

Step-by-Step Walkthrough

Stack State

Elements are stored in a simple stack

getMin() Call

Scan through all elements to find minimum

Linear Search

Compare each element until minimum is found

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>

#define MAX_SIZE 30000

typedef struct {
    int stack[MAX_SIZE];
    int top;
} MinStack;

MinStack* minStackCreate() {
    MinStack* obj = (MinStack*)malloc(sizeof(MinStack));
    obj->top = -1;
    return obj;
}

void minStackPush(MinStack* obj, int val) {
    if (obj->top < MAX_SIZE - 1) {
        obj->stack[++obj->top] = val;
    }
}

void minStackPop(MinStack* obj) {
    if (obj->top >= 0) {
        obj->top--;
    }
}

int minStackTop(MinStack* obj) {
    return obj->top >= 0 ? obj->stack[obj->top] : 0;
}

int minStackGetMin(MinStack* obj) {
    if (obj->top < 0) return 0;
    int minVal = INT_MAX;
    for (int i = 0; i <= obj->top; i++) {
        if (obj->stack[i] < minVal) {
            minVal = obj->stack[i];
        }
    }
    return minVal;
}

void minStackFree(MinStack* obj) {
    free(obj);
}

int main() {
    MinStack* minStack = minStackCreate();
    minStackPush(minStack, -2);
    minStackPush(minStack, 0);
    minStackPush(minStack, -3);
    printf("%d\n", minStackGetMin(minStack)); // -3
    minStackPop(minStack);
    printf("%d\n", minStackTop(minStack));    // 0
    printf("%d\n", minStackGetMin(minStack)); // -2
    minStackFree(minStack);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

getMin() requires scanning all n elements in the stack

✓ Linear Growth

Space Complexity

O(1)

Only uses the space for the main stack, no auxiliary data structures

✓ Linear Space

98.0K Views

Very High Frequency

~15 min Avg. Time

2.2K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Linear Scan) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler