最小栈

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

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

思路一：
本题的关键在于在常数时间内检索到最小元素。所以要用空间换时间，思路一采用辅助栈的方式来做。
主栈存储数据，辅助栈的栈顶存储当前栈内的最小元素。

辅助栈的具体操作流程如下：

将第一个元素入栈。

新加入的元素如果大于栈顶元素，那么新加入的元素就不处理。

新加入的元素如果小于等于栈顶元素，那么就将新元素入栈。

出栈元素不等于栈顶元素，不操作。

出栈元素等于栈顶元素，那么就将栈顶元素出栈。

class MinStack {
    private Stack<Integer> main;
    private Stack<Integer> min;
    /** initialize your data structure here. */
    public MinStack() {
        main = new Stack<Integer>();
        min = new Stack<Integer>();
    }
    
    public void push(int x) {
        main.push(x);
        if(min.empty() || x<=min.peek()){   //特别注意：这里等于的情况下也要进栈，否则会出错
            min.push(x);
        }
    }
    
    public void pop() {
        int n = main.pop();
        if(n==min.peek()){
            min.pop();
        }
    }
    
    public int top() {
        return main.peek();
    }
    
    public int getMin() {
        return min.peek();
    }
}

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

思路二：
思路一中，使用一个栈来保存最小值。可不可以使用一个int变量来保存最小值呢？

入栈 3 
|   |   min = 3
|   |     
|_3_|    
stack   

入栈 5 
|   |   min = 3
| 5 |     
|_3_|    
stack  

入栈 2 
| 2 |   min = 2?
| 5 |     
|_3_|    
stack  

但是这样一来，原来的最小值3就丢失了。解决办法：只需要在2入栈的时候先将3入栈即可。

入栈 2 ，同时将之前的 min 值 3 入栈，再把 2 入栈，同时更新 min = 2
| 2 |   min = 2
| 3 |  
| 5 |     
|_3_|    
stack  

入栈 6 
| 6 |  min = 2
| 2 |   
| 3 |  
| 5 |     
|_3_|    
stack  

出栈 6     
| 2 |   min = 2
| 3 |  
| 5 |     
|_3_|    
stack  

出栈 2     
| 2 |   min = 2
| 3 |  
| 5 |     
|_3_|    
stack  

这样，当我们出栈2时，将它下面的3也出栈，然后将min更新为3即可。

class MinStack {
    private Stack<Integer> main;
    private int min;
    /** initialize your data structure here. */
    public MinStack() {
        main = new Stack<Integer>();
        min = Integer.MAX_VALUE;
    }
    
    public void push(int x) {
        if(x<=min){   //特别注意：这里等于的情况下也要进栈，否则会出错
            main.push(min); 
            min = x;      
        }
        main.push(x);
    }
    
    public void pop() {
        int n = main.pop();
        if(n==min){
            min = main.pop();
        }
    }
    
    public int top() {
        return main.peek();
    }
    
    public int getMin() {
        return min;
    }
}

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