leetcode 155 最小栈

155、最小栈

1、这一道题有点意思啊，我是用了一个vector里面放了一个pair对去做的 这个pair值存了当前插入值之前对应的最小值，所以即使你出栈了数值，剩下的栈顶元素的pair的第二个仍然是当前的最小值

class MinStack {
public:
    /** initialize your data structure here. */
    vector<pair<int,int>> stk;
    
    MinStack() {        
        stk.push_back(make_pair<int,int>(0,INT_MAX));
    }
    
    void push(int x) {
        int newMin=min(x,stk[stk.size()-1].second);
        stk.push_back(make_pair(x,newMin));
    }
    
    void pop() {
        if(stk.size()>1)
            stk.pop_back();
    }
    
    int top() {
        return stk[stk.size()-1].first;
    }
    
    int getMin() {
        return stk[stk.size()-1].second;
    }
    
};

/**
 * 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();
 */

执行用时 :32 ms, 在所有 cpp 提交中击败了94.84%的用户
内存消耗 :17 MB, 在所有 cpp 提交中击败了34.12%的用户

下面改了一点，速度和空间都稳定的变好了

class MinStack {
public:
    /** initialize your data structure here. */
    vector<pair<int,int>> stk;
    
    MinStack() {        
        stk.push_back(make_pair<int,int>(0,INT_MAX));
    }
    
    void push(int x) {
        stk.push_back(make_pair(x,min(x,stk.back().second)));
    }
    
    void pop() {
        if(stk.size()>1)
            stk.pop_back();
    }
    
    int top() {
        return stk.back().first;
    }
    
    int getMin() {
        return stk.back().second;
    }
    
};

执行用时 :32 ms, 在所有 cpp 提交中击败了94.84%的用户
内存消耗 :16.8 MB, 在所有 cpp 提交中击败了73.22%的用户

2、然后看别人做了一个，使用两个栈做的，min栈是将最小值重复压栈，还有的就是把可能重复的最小值才重复压栈，出栈的时候就可以直接出了，比这个快，也比这个更省空间

class MinStack {
    stack<int> s1, m1;
public:
    /** initialize your data structure here. */
    MinStack() {
        
    }
    
    void push(int x) {
        s1.push(x); //s1先push一个进来
        if(m1.empty()) { //如果m1是空的，就也直接push进来
            m1.push(x);
        } else { //如果不空，保留最小值
            if(x<=m1.top()) m1.push(x);
            else m1.push(m1.top()); //这个就是把当前最小值重复压栈
        }
    }
    
    void pop() {
        s1.pop();
        m1.pop();
    }
    
    int top() {
        return s1.top();
    }
    
    int getMin() {
        return m1.top();
    }
};

执行用时 :36 ms, 在所有 cpp 提交中击败了84.40%的用户
内存消耗 :16.8 MB, 在所有 cpp 提交中击败了83.19%的用户

3、就是上面提到了那个做法

class MinStack {
private:
    stack<int> stk,minstk;
public:
    /** initialize your data structure here. */
    MinStack() {
        while(!stk.empty())stk.pop();
        while(!minstk.empty())minstk.pop();
    }
    
    void push(int x) {
        stk.push(x);
        if(minstk.empty()||x<=minstk.top())minstk.push(x);
    }
    
    void pop() {
        if(stk.empty())return;
        if(stk.top()==minstk.top())minstk.pop();
        stk.pop();
    }
    
    int top() {
        return stk.top();
    }
    
    int getMin() {
        return minstk.top();
    }
};

执行用时 :32 ms, 在所有 cpp 提交中击败了94.84%的用户
内存消耗 :16.8 MB, 在所有 cpp 提交中击败了76.84%的用户