剑指 Offer 30. 包含min函数的栈

博客地址：
https://mp.weixin.qq.com/s/hEGKU844FgHTurzXR39VYw
视频地址：
https://www.bilibili.com/video/BV1Df4y1w7b5?spm_id_from=333.999.0.0

class MinStack {
    LinkedList<Integer> stack1;
    LinkedList<Integer> stack2;

    /** initialize your data structure here. */
    public MinStack() {
        stack1=new LinkedList<Integer>();
        stack2=new LinkedList<Integer>();

    }
    
    public void push(int x) {
        stack1.addLast(x);
        if(stack2.isEmpty()){
            stack2.addLast(x);
        }else if(stack2.getLast()>=x){
            stack2.addLast(x);

        }else{
            stack2.addLast(stack2.getLast());
        }

    }
    
    public void pop() {
        stack1.removeLast();
        stack2.removeLast();

    }
    
    public int top() {
        return stack1.getLast();

    }
    
    public int min() {
        return stack2.getLast();

    }
}

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

class MinStack {

    // 创建两个栈
    // 创建栈 stack1 ，用来作为数据栈
    Stack<Integer> stack1;

    // 创建栈 stack2 ，用来作为辅助栈
    // stack2 存储 stack1 中所有【非严格降序】的元素
    // 这意味着 stack2 中的【栈顶元素】是 stack1 中的【最小元素】，维护好 stack2 和 stack1 的这种关系
    // 那么 min() 函数只需返回 stack2 的栈顶元素即可，并且时间复杂度为 O(1)
    Stack<Integer> stack2;

    // 这个函数是最小栈的初始化操作
    // 由于题目要求我们用两个栈实现最小栈，所以在这个函数中初始化的是两个栈
    public MinStack() {

        // 初始化 stack1 
        stack1 = new Stack<Integer>();

        // 初始化 stack2 
        stack2 = new Stack<Integer>();

    }

    // 这个函数是最小栈的压入操作
    public void push(int x) {

        // 数据栈 stack1 直接压入 x
        stack1.push(x);

        // 如果辅助栈 stack2 是空，可以直接压入 x
        // 此时，由于只有一个元素，stack2 中的【栈顶元素】是 stack1 中的【最小元素】
        if(stack2.empty()){
           // stack2 直接压入 x
           stack2.push(x);


        // 如果辅助栈 stack2 不为空
        // 那么考虑是否把 x 压入到辅助栈 stack2 中，目的是为了维护 stack2 和 stack1 的关系，让 stack2 中的【栈顶元素】是 stack1 中的【最小元素】
        }else{

            // 如果辅助栈 stack2 的栈顶元素大于或者等于 x ，那么可以把 x 压入到 stack2 中
            // 这样做，stack2 中的【栈顶元素】还是 stack1 中的【最小元素】
            if(stack2.peek() >= x){

                // 可以把 x 压入到 stack2 中
                stack2.push(x);

            // 如果辅助栈 stack2 的栈顶元素小于 x ，那么就不能把 x 压入到 stack2 中了
            }else{

                // 为了让 stack1 和 stack2 的元素个数相同，动画更美观
                // 这里执行一个操作，压入辅助栈【原来的栈顶元素】
                stack2.push(stack2.peek());
            }
        }
    }

    // 这个函数是最小栈的弹出操作
    // 栈的特征是先进后出
    public void pop() {
        // 数据栈 stack1 直接 pop
        stack1.pop();
        // 辅助栈 stack2 直接 pop
        stack2.pop();
    }

    // 这个函数是获取最小栈的栈顶元素操作
    // 栈的特征是先进后出
    public int top() {
         // 返回数据栈 stack1 的栈顶元素
         return stack1.peek();
    }

    // 这个函数是获取最小栈的最小元素操作
    public int min() {
         // 由于 stack2 中的【栈顶元素】是 stack1 中的【最小元素】
         // 所以，返回 stack2 的栈顶元素就是全部元素的最小值
         return stack2.peek();
    }
}