最小栈

设计一个支持 push，pop，top操作，并能在常数时间内检索到最小元素的栈。

push(x) —— 将元素 x 推入栈中。
pop() —— 删除栈顶的元素。
top() —— 获取栈顶元素。
getMin() —— 检索栈中的最小元素。

方法一：时间复杂度O(1)，空间复杂度O(N)

使用一个辅助栈 min_stack，每个元素 a 入栈时把当前栈的最小值 min_value 存储起来。在这之后无论何时，如果栈顶元素是 a，我们就可以直接返回存储的最小值 min_value。

1. push(x): 每当有新的值 x 进入时，如果 x <= min_stack.top()，则将值 x 放入min_stack 中，即更新栈顶的最小值。
2. pop(): 判断出栈的值是否为最小值，即与辅助栈 min_stack 栈顶元素值相等，如果是则将 min_stack 栈顶元素也pop()，这样保证了 min_stack 栈顶元素一直是 stack 中的最小值。
3. top(): 返回 stack 栈顶的元素值。
4. getMin(): 返回 min_stack 栈顶的元素值。

复杂度：时间复杂度O(1)，空间复杂度O(N)。

class MinStack {
private:
    stack<int> stk;
    stack<int> min_stk;
public:
    MinStack() {
        min_stk.push(INT_MAX);
    }
    
    void push(int val) {
        stk.push(val);
        min_stk.push(min(min_stk.top(),val));
    }
    
    void pop() {
        stk.pop();
        min_stk.pop();
    }
    
    int top() {
        return stk.top();
    }
    
    int getMin() {
        return min_stk.top();
    }
};

方法二：时间复杂度O(1)，空间复杂度O(1)

当题目有以下要求时，空间复杂度可以达到O(1)。栈里面存放的都是 int 整数，并且数值的范围是 [-100000, 100000]。 这是我们可以不使用辅助栈 min_stack，可以在栈中存入差值，就是存放栈顶与最小值的差值。

1. push(x): 每当有新的值 x 进入时，则将x与min的差值放入stack 中，并判断 x-min<0,即更新最小值min。
2. pop(): 判断出栈的值是否为最小值，即 stk.top()<0，如果是则将最小值更新 这样保证 min 一直是 stack 中的最小值。
3. top(): 返回 stack 栈顶的元素值 + min。
4. getMin(): 返回 stack 栈顶的元素值。

复杂度：时间复杂度O(1)，空间复杂度O(1)。

class MinStack {
    stack<int> stk;
    int min;

public:
    MinStack() {
    }
    
    void push(int val) {
        if(stk.empty()){
            min = val;
            stk.push(0);
        }else{
            stk.push(val-min);
            min = (val-min)<0? val:min;
        }
    }
    
    void pop() {
        int top = stk.top();
        min = top<0 ? (min-top):min;
        stk.pop();
    }
    
    int top() {
        return stk.top()+min;
    }
    
    int getMin() {
        return min;
    }
};