155.最小栈

目录

• 题目
  • 解题思路
    • 维护辅助栈
    • 用一个栈去解决（压入上一步的最小值）
    • 压入差值

题目

---

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

实现 MinStack 类:
MinStack() 初始化堆栈对象。
void push(int val) 将元素val推入堆栈。
void pop() 删除堆栈顶部的元素。
int top() 获取堆栈顶部的元素。
int 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.

解题思路

---

https://leetcode-cn.com/problems/min-stack/solution/xiang-xi-tong-su-de-si-lu-fen-xi-duo-jie-fa-by-38/

维护辅助栈

• 要求在常数时间内检索到最小值，就需要维护另一个结构寻找最小值，并且增删操作要同步更新

class MinStack {
    stack<int> minStack;
    stack<int> rtnminStack; //用来返回最小值
public:
    MinStack() {
        rtnminStack.push(INT_MAX);//先压入一个最大值
    }
    
    void push(int val) {
        rtnminStack.push(min(rtnminStack.top(),val));//保证最小值始终在栈顶
        minStack.push(val);
    }
    
    void pop() {
        rtnminStack.pop();//pop时要同步pop
        minStack.pop();
    }
    
    int top() {
        return minStack.top();
    }
    
    int getMin() {
        return rtnminStack.top();
    }
};

用一个栈去解决（压入上一步的最小值）

• 思路：如果要压入的值比上一步的最小值还要小，就要预存上一步的最小值，然后再压栈，并且要更新最小值为这一步的最小值（即压入的值）。pop时栈顶的值要么比最小值min大，要么等于min。

class MinStack {
    stack<int> minStack;
    int min;                //用来存每一步的最小值
public:
    MinStack() {
        min=INT_MAX;
    }
    
    void push(int val) {
        /*要压入的值小于等于之前的最小值，那就需要存储上一步的最小值再压入要压入的这个值，并且更新最小值
          要压入的值比min大的直接压栈*/
        if(val<=min){   
            minStack.push(min);
            min=val;
        }
        minStack.push(val);
    }
    
    void pop() {
        /*根据push的原理，pop的时候min若等于栈顶，则说明之前push的时候push的值（即栈顶）比最小值还要小
          所以pop时要pop掉两个，并更新最小值为上一步的最小值*/
        if(minStack.top()==min){
            minStack.pop();
            min=minStack.top();
        }
        minStack.pop();
    }
    
    int top() {
        return minStack.top();
    }
    
    int getMin() {
        return min;
    }
};

压入差值

class MinStack {
    stack<long long> minStack;      //用int会溢出！
    long long min;                  //用来存每一步的差值d_val
public:
    MinStack() {
        
    }
    
    void push(int val) {
        //单列出来栈空的情况：
        if(minStack.empty()){min=val;minStack.push(val-min);}   
        else{
            minStack.push(val-min);
            if(val<min)min=val;/*要压入的值比之前的最小值还要小则更新最小值*/
        }     
    }
    
    void pop() {        
        if(minStack.top()<0){//top()小于0说明之前压的值比最小值还要小，则把之前的最小值还原回去
            min=min-minStack.top();      
        }
        minStack.pop();
    }
    
    int top() {
        long long diff=minStack.top();
        if(diff>0)return min+diff;
        else return min;
    }
    
    int getMin() {
        return min;
    }
};