【LeetCode】【简单】《最小栈》

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

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

示例:

输入：["MinStack","push","push","push","getMin","pop","top","getMin"][[],[-2],[0],[-3],[],[],[],[]]

输出：[null,null,null,null,-3,null,0,-2]

解释：MinStack minStack = new MinStack();minStack.push(-2);minStack.push(0);minStack.push(-3);minStack.getMin();   --> 返回 -3.minStack.pop();minStack.top();      --> 返回 0.minStack.getMin();   --> 返回 -2.

提示：

pop、top 和 getMin 操作总是在 非空栈 上调用。

来源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/min-stack著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

---

要点：通过辅助栈来存储每次push后的最小值

第一次：  自己的代码真的是无比真实（别人的永远牛逼），自己做的时候没想到用stack  而是 vector 主要是工作中用的多，而vector 初始化的时候先预留部分内存可以提升部分push_back() 的效率（若没有预留空间，而随着元素增多可能会导致内存整块迁移，消耗时间），还是看后面官方题解和别人的题解吧。。。

class MinStack {
public:
    /** initialize your data structure here. */
    vector<int> minNumStack;
    int minNum;
    vector<int> vt;
    int topNum;
    MinStack() {
        topNum = 0;
        minNum = 0;
        minNumStack.reserve(10);
        vt.reserve(10);
    }
    
    void push(int x) {
        if (vt.size() == 0) {
            minNum = x;
        }
        vt.push_back(x);
        if (minNum > vt.back()) {
            minNum = x;
        }
        minNumStack.push_back(minNum);
        ++topNum;
    }
    
    void pop() {
        vt.pop_back();
        minNumStack.pop_back();
        minNum = minNumStack.back();
        --topNum;
    }
    
    int top() {
        return vt.back();
    }
    
    int getMin() {
        return minNum;
    }
};

/**
 * Your MinStack object will be instantiated and called as such:
 * MinStack* obj = new MinStack();
 * obj->push(x);
 * obj->pop();
 * int param_3 = obj->top();
 * int param_4 = obj->getMin();
 */

第二次：

class MinStack {
public:
    /** initialize your data structure here. */
    vector<int> minNumStack;

    vector<int> vt;
    int topNum;
    MinStack() {
        topNum = 0;
       
        minNumStack.reserve(10);
        vt.reserve(10);
    }
    
    void push(int x) {
        vt.push_back(x);
        if (minNumStack.size() == 0) {
            minNumStack.push_back(x);
        } else {
            if (minNumStack.back() > vt.back()) {
                minNumStack.push_back(vt.back());
            } else {
                minNumStack.push_back(minNumStack.back());
            }
        }
        ++topNum;
    }
    
    void pop() {
        vt.pop_back();
        minNumStack.pop_back();
        --topNum;
    }
    
    int top() {
        return vt.back();
    }
    
    int getMin() {
        return minNumStack.back();
    }
};

/**
 * Your MinStack object will be instantiated and called as such:
 * MinStack* obj = new MinStack();
 * obj->push(x);
 * obj->pop();
 * int param_3 = obj->top();
 * int param_4 = obj->getMin();
 */

总结：

针对vector的操作 要注意，当vector 为空的时候 不能进行 pop_back(); back();等操作

官方题解：

总结：

min函数可以直接用

直接用栈（stack） 更加好理解，而且

时间复杂度：对于题目中的所有操作，时间复杂度均为 O(1)O(1)。因为栈的插入、删除与读取操作都是 O(1)O(1)，我们定义的每个操作最多调用栈操作两次。

空间复杂度：O(n)O(n)，其中 nn 为总操作数。最坏情况下，我们会连续插入 nn 个元素，此时两个栈占用的空间为 O(n)O(n)。

class MinStack {
    stack<int> x_stack;
    stack<int> min_stack;
public:
    MinStack() {
        min_stack.push(INT_MAX);
    }
    
    void push(int x) {
        x_stack.push(x);
        min_stack.push(min(min_stack.top(), x));
    }
    
    void pop() {
        x_stack.pop();
        min_stack.pop();
    }
    
    int top() {
        return x_stack.top();
    }
    
    int getMin() {
        return min_stack.top();
    }
};

/*作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/min-stack/solution/zui-xiao-zhan-by-leetcode-solution/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。*/

以下是我看到一个感觉很不错的思路题解：

class MinStack {
public:
    /** initialize your data structure here. */
    MinStack() {
    }
    
    void push(int x) {
        if (st.size() == 0) {
            st.push({x, x});
        } else {
            st.push({x, min(x, st.top().second)});
        }
    }
    
    void pop() {
        st.pop();
    }
    
    int top() {
        return st.top().first;
    }
    
    int getMin() {
        return st.top().second;
    }
private:
    stack<pair<int, int>> st;
};

/**
 * Your MinStack object will be instantiated and called as such:
 * MinStack* obj = new MinStack();
 * obj->push(x);
 * obj->pop();
 * int param_3 = obj->top();
 * int param_4 = obj->getMin();
 */

/*作者：fuxuemingzhu
链接：https://leetcode-cn.com/problems/min-stack/solution/zui-yi-dong-yi-ge-zhan-tong-shi-bao-cun-dang-qian-/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。*/

总结：

可以使用pair<int, int> 作为栈的存储类型，同时将存入的 x 和 最小值 作为键值对一起放入栈，一一对应。（脑子灵活真的感觉牛逼）