题解 | #包含min函数的栈#

（1）辅助栈方法

使用两个栈维护数据，一个作为普通栈，一个保存历史最小值

public class Solution {
    //正常栈操作
    private Stack<Integer> stack = new Stack<Integer>();
    //保存最小值栈
    private Stack<Integer> mins = new Stack<Integer>();
    public void push(int node) {
         stack.push(node);
         //最小值栈为空或元素小于最小值栈顶元素则入栈
         if(mins.isEmpty() || node <= mins.peek())
             mins.push(node);
    }
    
    public void pop() {
    	//两个栈顶元素相同则最小值栈顶也需要弹出
         if(stack.peek().equals(mins.peek()))
             mins.pop();
         stack.pop();
    } 
    
    public int top() {
        return stack.peek();
    }
    
    public int min() {
        return mins.peek();
    }
}

（2）记录最小值方法

public class Solution {
    //正常栈操作
    private Stack<Integer> stack = new Stack<Integer>();
    //保存最小值
    int min;
    public void push(int node) {
        if (stack.isEmpty()) {
            min = node;
            stack.push(node - min);
        } else {
        	//栈中存放node-当前最小值的结果
            stack.push(node - min);
            //更新最小值
            if (node > min) {
                min = node;
            }
        }
    }
    
    public void pop() {
        int tmp = stack.pop();
        if (tmp < 0) {
            //出栈时，如果栈顶值大于零，说明上一个最小值和当前一样，不需要变动；
            //如果小于零，则上一个最小值=当前最小值-栈顶值(因为栈顶值=node-min)
            min = min - tmp;
        }
    } 
    
    public int top() {
    	//栈顶小于0，最小值在该位置发生变化，目前最小值为该位置元素值
        if(stack.peek() < 0){
            return min;
        }
        //正常还原元素值
        else{
            return stack.peek() + min;
        }
    }
    
    public int min() {
        return min;
    }
}