letcode--最小栈

题目

设计一个支持 push ，pop ，top 操作，并能在常数时间内检索到最小元素的栈。
push(x) —— 将元素 x 推入栈中。
pop() —— 删除栈顶的元素。
top() —— 获取栈顶元素。
getMin() —— 检索栈中的最小元素。

示例

输入：
["MinStack","push","push","push","getMin","pop","top","getMin"]
[[],[-2],[0],[-3],[],[],[],[]]

输出：
[null,null,null,null,-3,null,0,-2]

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

方法一：基于数组实现的最小栈

最基本的思考方式，基于数组，没进行任何的优化

class MinStack {

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

结果（1）：并不理想，下面我们进行优化

方法二：利用一个辅助栈来实现

我们主要是为了实现最小栈，因此我们可以定义两哥栈来实现，stack和min_stack.
(入栈)：当入栈的值x比min_stack栈顶的元素小且等于时，min_stack执行入栈操作，stack正常入栈(出栈)：当要出栈的元素和min_stack的栈顶元素相等时，min_stack才执行出栈操作，stack正常出栈
(最小值)：最小值就是min_stack的栈顶元素

class MinStack {
    /** initialize your data structure here. */
    private Stack<Integer> stack;
    private Stack<Integer> min_Stack;

    public MinStack() {
        stack = new Stack<>();
        min_Stack = new Stack<>();
    }

    public void push(int x) {
        stack.push(x);
        if (!min_Stack.isEmpty()) {

            //当min_stack中的元素大于等于x时进栈
            if (x <= min_Stack.peek()) {
                min_Stack.push(x);
            }
        }else{
            min_Stack.push(x);
        }
    }

    public void pop() {
        int pop = stack.pop();
        //当Stack和min_Stack栈顶相等的时候,min_stack出栈
        if (pop == min_Stack.peek()) {
            min_Stack.pop();
        }
    }
  
    public int top() {
        return stack.peek();
    }

    public int getMin() {
        return min_Stack.peek();
    }
}

结果（2）：可以看出不管是时间还是内存都有了很大的提升

方法三: 使用一个链表来实现也非常有效率

直接用一个链表即可实现栈的基本功能，那么最小值该怎么得到呢？我们可以在 Node 节点中增加一个 min 字段，这样的话每次加入一个节点的时候，我们同时只要确定它的 min 值即可。

class MinStack {
    class Node{
        int value;
        int min;
        Node next;

        Node(int x, int min){
            this.value=x;
            this.min=min;
            next = null;
        }
    }
    Node head;
    //每次加入的节点放到头部
    public void push(int x) {
        if(null==head){
            head = new Node(x,x);
        }else{
            //当前值和之前头结点的最小值较小的做为当前的 min
            Node n = new Node(x, Math.min(x,head.min));
            n.next=head;
            head=n;
        }
    }

    public void pop() {
        if(head!=null)
            head =head.next;
    }
    
    public int top() {
        if(head!=null)
            return head.value;
        return -1;
    }

    public int getMin() {
        if(null!=head)
            return head.min;
        return -1;
    }
}

结果（3）