Min Stack

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

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

✓ Brute Force (Linear Scan)

⏱️ Time: O(n) Space: O(1)

Store elements in a simple stack. For getMin(), iterate through all elements to find the minimum value. This approach is straightforward but violates the O(1) time requirement for getMin().

Two Stack Approach (Optimal)

⏱️ Time: O(1) Space: O(n)

Maintain two stacks - the main stack for elements and an auxiliary stack for minimums. When pushing, also push the current minimum to the auxiliary stack. This ensures O(1) access to the minimum at any point.

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 <string.h>
#include <limits.h>

#define MAX_SIZE 30000
#define MAX_OPS 100

// Move large arrays to global scope to avoid stack overflow
static char operations_line[10000];
static char values_line[10000];
static char operations[MAX_OPS][20];
static int values[MAX_OPS][10];
static int value_sizes[MAX_OPS];
static char result[MAX_OPS][20];

typedef struct {
    int stack[MAX_SIZE];
    int min_stack[MAX_SIZE];
    int top_idx;
} MinStack;

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

void minStackPush(MinStack* obj, int val) {
    if (obj->top_idx < MAX_SIZE - 1) {
        obj->top_idx++;
        obj->stack[obj->top_idx] = val;
        if (obj->top_idx == 0) {
            obj->min_stack[obj->top_idx] = val;
        } else {
            int prev_min = obj->min_stack[obj->top_idx - 1];
            obj->min_stack[obj->top_idx] = (val < prev_min) ? val : prev_min;
        }
    }
}

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

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

int minStackGetMin(MinStack* obj) {
    return obj->top_idx >= 0 ? obj->min_stack[obj->top_idx] : INT_MIN;
}

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

int main() {
    if (!fgets(operations_line, sizeof(operations_line), stdin)) return 1;
    if (!fgets(values_line, sizeof(values_line), stdin)) return 1;
    
    // Remove newlines
    operations_line[strcspn(operations_line, "\n")] = 0;
    values_line[strcspn(values_line, "\n")] = 0;
    
    // Parse operations - handle quoted strings
    int op_count = 0;
    char* ptr = operations_line;
    while (*ptr && op_count < MAX_OPS) {
        // Skip whitespace and commas
        while (*ptr == ' ' || *ptr == ',' || *ptr == '[') ptr++;
        if (*ptr == ']' || *ptr == '\0') break;
        
        // Handle quoted strings
        if (*ptr == '"') {
            ptr++; // skip opening quote
            char* start = ptr;
            while (*ptr && *ptr != '"') ptr++;
            int len = ptr - start;
            if (len > 0 && len < 19) {
                strncpy(operations[op_count], start, len);
                operations[op_count][len] = '\0';
                op_count++;
            }
            if (*ptr == '"') ptr++; // skip closing quote
        } else {
            // Handle unquoted strings (shouldn't happen but just in case)
            char* start = ptr;
            while (*ptr && *ptr != ',' && *ptr != ']' && *ptr != ' ') ptr++;
            int len = ptr - start;
            if (len > 0 && len < 19) {
                strncpy(operations[op_count], start, len);
                operations[op_count][len] = '\0';
                op_count++;
            }
        }
    }
    
    // Parse values - find each [x,y,z] pattern
    ptr = values_line;
    for (int i = 0; i < op_count; i++) {
        value_sizes[i] = 0;
        // Find opening bracket
        while (*ptr && *ptr != '[') ptr++;
        if (*ptr == '[') {
            ptr++; // skip '['
            // Check if empty array
            while (*ptr == ' ') ptr++;
            if (*ptr == ']') {
                ptr++; // skip ']'
                continue;
            }
            
            // Parse numbers until closing bracket
            while (*ptr && *ptr != ']') {
                while (*ptr == ' ' || *ptr == ',') ptr++;
                if (*ptr == ']' || *ptr == '\0') break;
                
                char* endptr;
                long val = strtol(ptr, &endptr, 10);
                if (endptr != ptr) { // Successfully parsed a number
                    values[i][value_sizes[i]++] = (int)val;
                    ptr = endptr;
                } else {
                    ptr++; // skip invalid character
                }
            }
            if (*ptr == ']') ptr++; // skip closing ']'
        }
    }
    
    MinStack* minStack = NULL;
    
    for (int i = 0; i < op_count; i++) {
        if (strcmp(operations[i], "MinStack") == 0) {
            minStack = minStackCreate();
            strcpy(result[i], "null");
        } else if (strcmp(operations[i], "push") == 0) {
            minStackPush(minStack, values[i][0]);
            strcpy(result[i], "null");
        } else if (strcmp(operations[i], "pop") == 0) {
            minStackPop(minStack);
            strcpy(result[i], "null");
        } else if (strcmp(operations[i], "top") == 0) {
            sprintf(result[i], "%d", minStackTop(minStack));
        } else if (strcmp(operations[i], "getMin") == 0) {
            sprintf(result[i], "%d", minStackGetMin(minStack));
        }
    }
    
    printf("[");
    for (int i = 0; i < op_count; i++) {
        printf("%s", result[i]);
        if (i < op_count - 1) printf(",");
    }
    printf("]\n");
    
    if (minStack) 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