一【题目类别】

二【题目难度】

简单

三【题目编号】

剑指 Offer 30.包含min函数的栈

四【题目描述】

定义栈的数据结构，请在该类型中实现一个能够得到栈的最小元素的 min 函数在该栈中，调用 min、push 及 pop 的时间复杂度都是 O(1)。

五【题目示例】

示例:
- MinStack minStack = new MinStack();
- minStack.push(-2);
- minStack.push(0);
- minStack.push(-3);
- minStack.min(); --> 返回 -3.
- minStack.pop();
- minStack.top(); --> 返回 0.
- minStack.min(); --> 返回 -2.

六【题目提示】

各函数的调用总次数不超过 20000 次

七【解题思路】

设置一个辅助栈stack2，使用主栈stack1进行正常的栈操作
如果要进栈，将要入栈的值和stack2栈顶的值比较，将更小的值入stack2栈，也就是说，stack2栈保存了每一个时刻当前栈的最小值
如果要出栈，stack1栈和stack2栈同时出栈，因为stack2栈保存的当前时刻的最小值要随着当前时刻的stack1栈中的值一起出栈，且它们是一一对应的关系
如果要求最小值，直接弹出stack2栈顶的值即可，因为stack2栈的栈顶保存了当前时刻栈中的最小值
如果要求栈顶元素，直接返回stack1栈顶的值即可，这里和正常栈操作一样
如果使用C语言编写代码，最后别忘了释放空间

八【时间频度】

时间复杂度： $O (1)$
空间复杂度： $O (n)$ ， $n$ 为压入栈的元素数量

九【代码实现】

Java语言版

class MinStack {

    Stack<Integer> stack1;
    Stack<Integer> stack2;

    public MinStack() {
        stack1 = new Stack<>();
        stack2 = new Stack<>();
        stack2.push(Integer.MAX_VALUE);
    }
    
    public void push(int x) {
        stack1.push(x);
        stack2.push(Math.min(x,stack2.peek()));
    }
    
    public void pop() {
        stack1.pop();
        stack2.pop();
    }
    
    public int top() {
        return stack1.peek();
    }
    
    public int min() {
        return stack2.peek();
    }
    
}

C语言版

#define MAX_SIZE 20001

typedef struct 
{
    int* stack1;
    int top1;
    int* stack2;
    int top2;
} MinStack;


MinStack* minStackCreate() 
{
    MinStack* obj = (MinStack*)malloc(sizeof(MinStack));
    obj->stack1 = (int*)malloc(sizeof(int)*MAX_SIZE);
    obj->top1 = -1;
    obj->stack2 = (int*)malloc(sizeof(int)*MAX_SIZE);
    obj->top2 = -1;
    obj->stack2[++obj->top2] = INT_MAX;
    return obj;
}

void minStackPush(MinStack* obj, int x) 
{
    obj->stack1[++obj->top1] = x;
    obj->stack2[++obj->top2] = fmin(x,obj->stack2[obj->top2]);
}

void minStackPop(MinStack* obj) 
{
    obj->top1--;
    obj->top2--;
}

int minStackTop(MinStack* obj) 
{
    return obj->stack1[obj->top1];
}

int minStackMin(MinStack* obj) 
{
    return obj->stack2[obj->top2];
}

void minStackFree(MinStack* obj) 
{
    free(obj->stack1);
    free(obj->stack2);
    free(obj);
}

Python语言版

class MinStack:

    def __init__(self):
        self.stack1 = []
        self.stack2 = [math.inf]

    def push(self, x: int) -> None:
        self.stack1.append(x)
        self.stack2.append(min(x,self.stack2[-1]))

    def pop(self) -> None:
        self.stack1.pop()
        self.stack2.pop()

    def top(self) -> int:
        return self.stack1[-1]

    def min(self) -> int:
        return self.stack2[-1]

C++语言版

class MinStack {
public:
    stack <int> stack1;
    stack <int> stack2;
    MinStack() {
        stack2.push(INT_MAX);
    }
    
    void push(int x) {
        stack1.push(x);
        stack2.push(fmin(x,stack2.top()));
    }
    
    void pop() {
        stack1.pop();
        stack2.pop();
    }
    
    int top() {
        return stack1.top();
    }
    
    int min() {
        return stack2.top();
    }
};