最小栈三种不同方式实现 java版本

155. 最小栈

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

• push(x) —— 将元素 x 推入栈中。

• pop() —— 删除栈顶的元素。

• top() —— 获取栈顶元素。

• getMin() —— 检索栈中的最小元素。

方法一：两个栈实现，辅助栈同步保存最小值

class MinStack {
    private Deque<Integer> stack;
    private Deque<Integer> minStack;

    public MinStack() {
        stack = new ArrayDeque<>();
        minStack = new ArrayDeque<>();
    }
    
    public void push(int val) {
        stack.push(val);
        if(minStack.isEmpty() ){
            minStack.push(val);
        } else {
            if(getMin()> val){
                minStack.push(val);
            } else {
                minStack.push(getMin());
            }
        }
    }
    
    public void pop() {
        stack.pop();
        minStack.pop();
        
    }
    
    public int top() {
       return stack.peek();
    }
    
    public int getMin() {
        return minStack.peek();
    }
}

方法二：两个栈实现，辅助栈异步保存最小值

同方法一类似，但是本方法使用的辅助栈不是把最小值一一对应的写到辅助栈中，辅助栈是一个单调栈

，栈底到栈顶是单调递减的。

辅助栈和数据栈不同步

特点：由“辅助栈和数据栈同步”的思想，我们知道，当数据栈进来的数越来越大的时候，我们要在辅助栈顶放置和当前辅助栈顶一样的元素，这样做有点“浪费”。基于这一点，我们做一些“优化”，但是在编码上就要注意一些边界条件。

（1）辅助栈为空的时候，必须放入新进来的数；

（2）新来的数小于或者等于辅助栈栈顶元素的时候，才放入，特别注意这里“等于”要考虑进去，因为出栈的时候，连续的、相等的并且是最小值的元素要同步出栈；

（3）出栈的时候，辅助栈的栈顶元素等于数据栈的栈顶元素，才出栈。

总结一下：出栈时，最小值出栈才同步；入栈时，最小值入栈才同步。

对比：个人觉得“同步栈”的方式更好一些，因为思路清楚，因为所有操作都同步进行，所以调试代码、定位问题也简单。“不同步栈”，虽然减少了一些空间，但是在“出栈”、“入栈”的时候还要做判断，也有性能上的消耗。

参考链接：https://leetcode-cn.com/problems/min-stack/solution/shi-yong-fu-zhu-zhan-tong-bu-he-bu-tong-bu-python-/

class MinStack {
    private Deque<Integer> stack;
    private Deque<Integer> helper;

    public MinStack() {
        stack = new ArrayDeque<>();
        helper = new ArrayDeque<>();
    }
    
    public void push(int val) {
        stack.push(val);
        if(helper.isEmpty() || getMin()>= val){
            helper.push(val);
        }
    }
    
    public void pop() {
        int val = stack.pop();
        if(val== getMin()){
            helper.pop();
        }
    }

    public int top() {
       return stack.peek();
    }
    
    public int getMin() {
        return helper.peek();
    }
}

方法三：一个栈（栈存放一个数组）把当前最小数值也存放栈中

每个栈里的元素存放的最小值，也是一个单调递减的数列。

class MinStack {
    private Deque<int[]> stack;

    public MinStack() {
        stack = new ArrayDeque<>();
    }
    
    public void push(int val) {
        if(stack.isEmpty() ){
            stack.push(new int[]{val, val});
        } else {
            stack.push(new int[]{val, Math.min(val,getMin())});  
        }
    }
    
    public void pop() {
        stack.pop();
    }
    
    public int top() {
       return stack.peek()[0];
    }
    
    public int getMin() {
        return stack.peek()[1];
    }
}