[LeetCode] 155.最小栈

最小栈设计这道题目，之前在面试字节跳动的时候，有被问到过，但是基础太差，没有刷过leetcode，不会做这个题目，今天练习刷到这道题目，很是感慨。第一反应是想到用数组模拟栈，但是这样做不能常数时间内找出最小值。当时面试官一直问我有没有其他办法实现，我却回答不出来。

155.最小栈

题目描述：

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

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

MinStack minStack = new MinStack();
minStack.push(-2);
minStack.push(0);
minStack.push(-3);
minStack.getMin(); --> 返回 -3.
minStack.pop();
minStack.top(); --> 返回 0.
minStack.getMin(); --> 返回 -2.

参考网友分享的思路，第一次学到同步压栈的方法解出题目，很是巧妙，特此记录分享。

解题思路1：不同步压栈，空间换时间

辅助栈和数据栈不同步

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

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

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

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

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

class MinStack {

    //同步压栈，空间换时间
    //数据栈
    Stack<Integer> dataStack;
   // 辅助栈，最小栈，保存最小值
    Stack<Integer> minStack;

    /** initialize your data structure here. */
    public MinStack() {
        dataStack = new Stack<Integer>();
        minStack = new Stack<Integer>();
    }
    
    //使用栈，注意判空，将新元素压栈同时判断当前元素是否是最小元素，如果是，同步压栈，用空间换时间 
    public void push(int x) {
        dataStack.push(x);
        //如果最小栈为空，或者当前压栈元素值<=最小栈栈顶元素（min）,当前元素都要压栈
        if(minStack.empty() || x <= minStack.peek()) {
            minStack.push(x);
        }
    }
    
    //使用栈，注意判空     
    public void pop() {
        if(dataStack.empty()){
            throw new RuntimeException("stack is empty!");
        }
        //如果数据栈栈顶元素和最小栈栈顶元素相同（min），两个栈顶元素同步出栈
        int x = dataStack.pop();
        if(x == minStack.peek()){
            minStack.pop();
        }
    }
    
    //使用栈，注意判空
    public int top() {
        if(!dataStack.empty()){
            return dataStack.peek();
        } else {
            throw new RuntimeException("stack is empty!");
        }
        
    }
    
    //使用栈，注意判空
    public int getMin() {
        if(!minStack.empty()){
            return minStack.peek();
        } else {
            throw new RuntimeException("stack is empty!");
        } 
    }
}

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

复杂度分析

• 时间复杂度：O(1)，出栈、入栈、查看栈顶元素，只需有限个步骤，跟数据规模大小无关，这些操作时间复杂度为O(1)
• 空间复杂度：O(N)，N是读入的数据个数

解决思路2：数据栈和最小栈（辅助栈）同步

辅助栈和数据栈同步
特点：编码简单，不用考虑一些边界情况，就有一点不好：辅助栈可能会存一些“不必要”的元素。

class MinStack {

    // 数据栈
    private Stack<Integer> data;
    // 辅助栈
    private Stack<Integer> helper;

    /**
     * initialize your data structure here.
     */
    public MinStack() {
        data = new Stack<>();
        helper = new Stack<>();
    }

    // 思路 1：数据栈和辅助栈在任何时候都同步

    public void push(int x) {
        // 数据栈和辅助栈一定会增加元素
        data.add(x);
        if (helper.isEmpty() || helper.peek() >= x) {
            helper.add(x);
        } else {
            //复制栈顶最小元素，保证同步出栈的时候，最小值不变
            helper.add(helper.peek());
        }
    }

    public void pop() {
        // 两个栈都得 pop
        if (!data.isEmpty()) {
            helper.pop();
            data.pop();
        }
    }

    public int top() {
        if(!data.isEmpty()){
            return data.peek();
        }
        throw new RuntimeException("栈中元素为空，此操作非法");
    }

    public int getMin() {
        if(!helper.isEmpty()){
            return helper.peek();
        }
        throw new RuntimeException("栈中元素为空，此操作非法");
    }
}

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

复杂度分析

• 时间复杂度：O(1)，出栈、入栈、查看栈顶元素，只需有限个步骤，跟数据规模大小无关，这些操作时间复杂度为O(1)
• 空间复杂度：O(N)，N是读入的数据个数

解题思路3：用链表实现最小栈

思路：拿到题后首先想到，栈的实现可以通过ArrayList或者LinkedList（我使用的是链表）. 而最小栈只需要用一个整数minNum记录栈中的最小值即可。

• push(): 每一次入栈，即为链表添加元素。与此同时，将添加的元素与minNum进行比较。
• pop(): 首先判断链表最后一个元素是否与minNum值相等。若相等，则从头遍历链表，找出第二小的元素。最后删除链表最后一个元素。

class MinStack {

    List<Integer> list = new LinkedList<Integer>();
    int minNum = Integer.MAX_VALUE;
    
    /** initialize your data structure here. */
    public MinStack() {
        
    }  
    public void push(int x) {
        list.add(x);
        if(x<minNum){
            minNum=x;
        }
    }   
    public void pop() {
        if(minNum==list.get(list.size()-1)){
            minNum=Integer.MAX_VALUE;
            for(int i=0;i<list.size()-1;i++){
                if(list.get(i)<minNum){
                    minNum=list.get(i);
                }
            }
        }
        if(list.size()!=0){
            list.remove(list.size()-1);
        } 
    }
    
    public int top() {  
        return list.get(list.size()-1);
    }
    
    public int getMin() {
        return minNum;
    }
}