包含min函数的栈（剑指offer）

一、题目描述：

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

二、题目分析：

    第一眼看这道题，嗯？就是求一个最小值？直接遍历一遍不就OK啦？然后看到括号里要求了时间复杂度为O（1），emmm，看来没那么简单。再仔细看这道题，要求“定义栈的数据结构”，也就是要实现：入栈、出栈、求栈顶元素这些操作，再加上一个求栈中元素最小值的操作。入栈、出栈、求栈顶元素这些都可以通过栈本身实现，但是求最小值不能，因此，也就需要对入栈、出栈操作进行进一步加工，使得在入出栈过程中就可以得到当前的最小值。这个就是这道题的基本思路。

三、题解：

    既然要对入出栈进行加工，那么就分析一下该怎么加工。入栈好说，每次入栈时，将当前最小值和入栈的值进行比较，若当前值更小，则更新最小值。出栈则没那么简单，因为如果出栈的值就是当前的最小值，并且栈中的已经没有和当前值相等的值，也就意味着需要更新最小值，把最小值恢复到上一个，因此，怎么恢复最小值就是这道题的解题关键！

1.双栈法：

    既然出栈时可能需要恢复上一个最小值，那么我们可以把每次入栈时的入栈值对应的当前最小值用一个“辅助栈”存起来，出栈的时候，同时出栈，就可以实现对当前栈中最小值的恢复。代码如下：

import java.util.Stack;
/**
 * Created by rongshuai on 2020/1/22 18:36
 */
public class Solution2_双栈 {

    Stack<Integer> stack1 = new Stack<>();//用来正常存值
    Stack<Integer> stack2 = new Stack<>();//用来存每个值对应的当前最小值
    public void push(int node){
        if(stack1.empty()){//如果是首次入栈
            stack1.push(node);
            stack2.push(node);
        }else{
            stack1.push(node);
            int minimum = stack2.peek();//取当前最小值
            if(minimum>node){//如果遇到更小的值
                stack2.push(node);
            }else{//如果没遇到比当前最小值更小的值
                stack2.push(minimum);
            }
        }
    }

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

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

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

2.压缩还原法：

    上面一种方法用到了“辅助栈”，其作用是为了记录入栈过程中不断更新的“当前最小值”。我们可以思考一下，“辅助栈”是否真的有必要。其实，我们可以这样做：入栈的时候，存储的不是入栈的值，而是入栈值和“上一个最小值”之间的差值。比如，如果入栈序列是：4,3,2,2,3,1，那么存入的值就应该是：0（4-4），-1（3-4），-1（2-3），0（2-2），1（3-2），-1（1-2）。出栈的时候，如果出栈的值为负，说明该值就是当前的最小值，因此，需要更新最小值，我们先看一下当前出栈的值（diff）是怎么得到的：入栈值-之前栈中的最小值，这个“之前栈中的最小值”就是上一个最小值，而由于出栈值对应的入栈值就是我们当前的最小值，因此，上一个最小值（minimum）=当前最小值（minimum） - 出栈值（diff），而栈顶元素就等于：当前栈顶值 + 当前最小值，代码如下：

import java.util.Stack;
/**
 * Created by rongshuai on 2020/1/22 17:59
 */
public class Solution1_压缩还原 {

    int minimum;
    Stack<Integer> stack = new Stack<Integer>();
    public void push(int node){//入栈处理，主要目的：存储 + 更新最小值
        if(stack.empty()){//首次入栈
            minimum = node;
            stack.push(0);
        }
        else{
            stack.push(node-minimum);//入栈值为当前入栈元素和当前最小值之间的差值
            if(minimum>node){//如果遇到了新的最小值
                minimum = node;
            }
        }
    }

    public void pop(){//出栈处理，目的：出栈 + 恢复上一个最小值
        int diff = stack.pop();
        if(diff<0){//如果当前的栈顶元素为负，说明当前栈顶元素是最小值
            minimum = minimum - diff;//恢复上一个最小值
        }
    }

    public int top(){//恢复栈顶元素
        return stack.peek() + minimum;
    }

    public int min(){
        return minimum;
    }
}