牛客网刷题汇总

1. 定义栈的数据结构，请在该类型中实现一个能够得到栈中所含最小元素的min函数（时间复杂度应为O（1））。

注意：保证测试中不会当栈为空的时候，对栈调用pop()或者min()或者top()方法。

分析：

 方法一、首先想到的是用两个栈来分别来保存数据。栈一stackTotal用来保存所有的数据，栈二stackLittle加入新的元素后当前stackTotal中对应的最小值，当新的元素小于“stackLittle”栈顶元素时，“stackLittle”像栈顶push新来的元素，否则，“stackLittle”向栈顶加入原栈顶元素。执行“pop”方法时，两个栈同时弹出各自的栈顶元素。

代码实现：

public class Solution {

    Stack<Integer> stackTotal = new Stack<Integer>();

    Stack<Integer> stackLittle = new Stack<Integer>();

    public void push(int node) {

        stackTotal.push(node);

        if(stackLittle.empty()){
            stackLittle.push(node);
        }else{
            if(node <= stackLittle.peek()){
                stackLittle.push(node);
            }else{
                stackLittle.push(stackLittle.peek());
            }
        }
    }

    public void pop() {
        stackTotal.pop();
        stackLittle.pop();
    }

    public int top() {
        return stackTotal.peek();
    }
    public int min() {
        return stackLittle.peek();
    }

}

方法二： 压缩还原法，这个方法是用一个栈来存储的。链接：

我们发现其实最小值min它本身就是一种冗余信息。为什么呢？因为每个元素在数值上都包含了min值，举个例子，假设入栈序列为：4、5、6、3、2、1，那么各轮次对应的min值就是：4、4、4、3、2、1，发现有：
4=4+0，5=4+1，6=4+2，3=4+(-1)，2=3+(-1)，1=2+(-1)；各个元素在数值上已经包含了在它之前的最小值的值；
那么，我们是不是只要在数据栈中存储0、1、2、-1、-1、-1，然后再使用一个辅助变量min=1就可以了呢？
这样，根据单个辅助变量和栈中存储的值就能够推理出top值和min值了，具体规则如下：

入栈：

• 压缩：将要入栈的元素value减去当前最小值min，得到一个差值diff，只存储该差值；
• 更新：如果入栈的元素value比当前最小值min小，则要更新最小值：min=value；
• 初始：第一次入栈比较特殊，因为此时的min变量并没有值，所以令：min=value；

出栈：

• 更新：如果栈中存储的差值diff是负数，说明出栈的元素是当前最小值min，也就是当diff是负数的时候，当前的top就是栈中最小的，需要把min值更新为上一个最小值min = min - diff，否则，出栈的元素不是最小值，则不对min变量做任何操作；
• 还原：如果栈中存储的差值diff是正数，diff是正数的时候，当前的最小值跟上一位置最小值是同一一个，说明 top = min + diff，否则，说明top元素本身是最小值 top = min；
• 注意：红色字体，理解了红色字体，有点绕

代码二： 

package com.zte.st.dailybuild.domain.TooBox.newTool.Operation.Modal.params.Stream;

import java.util.Stack;
/**
 * Created by 6092002943 on 2020/3/31.
 */
public class Test {

    static Stack<Integer> stack_ = new Stack<Integer>();
    private static int top_;

    static int min_;

    public static void main(String[] args) {
        push(4);
        push(5);
        push(6);
        push(3);
        push(2);
        push(1);
        push(1);
        push(2);
        push(3);
    }


    public static void push(int value) {
        if (stack_.empty()) // 第一次入栈需要额外考虑
            min_ = value;

        stack_.push(value - min_); // 存储入栈元素与最小值的差值
        if (value < min_) // 如果入栈元素比最小值要小则更新最小值
            min_ = value;//注意出栈的时候，top = min
        top_ = value; //.......更新最新元素(top)的值
    }

    public static void pop() {
        if (!stack_.empty()) {
            // 如果出栈的是最小值(体现为存储值为负)，则需要更新最小值
            if (stack_.peek() < 0)
                min_ -= stack_.peek();
            stack_.pop();

            if (!stack_.empty()) // 出栈需要更新 top 的值
                top_ = min_ + (stack_.peek() > 0 ? stack_.peek() : 0);//当前
        }
    }

    static int top() {
        return top_;//总是指向栈顶元素
    }

    static int min() {
        return min_;
    }
}