LeetCode155. Min Stack

155.Min Stack
Design a stack that supports push, pop, top, and retrieving the minimum element in constant time.
本题设计一个栈，包括4个功能，入栈push（），出栈pop（），返回栈顶元素top（），返回栈的最小值getMin（）；

push(x) -- Push element x onto stack.  
pop() -- Removes the element on top of the stack.  
top() -- Get the top element.  
getMin() -- Retrieve the minimum element in the stack.  

Example:

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

方法一：
ByMyself，用 ArrayList 来做。

public class MinStack_155 {
     /** initialize your data structure here. */
    List<Integer> list = new ArrayList<>();
    public MinStack_155() {     

    }  
    public void push(int x) {
        list.add(x);    
    }

    public void pop() {
        list.remove(list.size()-1);
    }

    public int top() {
        return list.get(list.size()-1);
    }

    public int getMin() {
        int min = Integer.MAX_VALUE;
        for(int i = 0; i < list.size(); i++){
            if(list.get(i) < min){
                min = list.get(i);
            }
        }
        return min;
    }
}

方法二：
也是用的 ArrayList， 但是这个在检索最小值时用时很短，比方法一好.

class MinStack {

    private int min;
    private List<Integer> list;

    /** initialize your data structure here. */
    public MinStack() {
        min = Integer.MAX_VALUE;
        list = new ArrayList<Integer>();
    }

    public void push(int x) {
        list.add(x);        
        if (x < min) min = x;        
    }

    public void pop() {
        if (list.size() == 0) return;       
        int removed = list.remove(list.size()-1);       
        if (removed != min) return;       
        // udpdate min.
        int newMin = Integer.MAX_VALUE;
        for (Integer i : list)
        {
            if (i < newMin)
            {
                newMin = i;
            }
        }        
        min = newMin;       
    }

    public int top() {
        if (list.size() == 0) return -1;        
        return list.get(list.size()-1);
    }

    public int getMin() {
        return min;
    }
}

方法三：
使用 Stack 栈，通过 push 和 pop 的过程就已经识别了最小值。

class MinStack3 {
    Stack<Integer> st = new Stack<>();
    int min = Integer.MAX_VALUE;
    /** initialize your data structure here. */
    public MinStack3() {

    }

    public void push(int x) {
        if(x <= min){
            st.push(min);
            min = x;
        }
        st.push(x);
    }

    public void pop() {
        if(st.pop() == min){
            min = st.pop();
        }
    }

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

    public int getMin() {
        return min;
    }
}

方法四：

class MinStack4 {
    long min;
    Stack<Long> stack;

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

    public void push(int x) {
        if (stack.isEmpty()){
            stack.push(0L);
            min=x;
        }else{
            stack.push(x-min);//Could be negative if min value needs to change
            if (x<min) min=x;
        }
    }

    public void pop() {
        if (stack.isEmpty()) return;

        long pop=stack.pop();

        if (pop<0)  min=min-pop;//If negative, increase the min value

    }

    public int top() {
        long top=stack.peek();
        if (top>0){
            return (int)(top+min);
        }else{
           return (int)(min);
        }
    }

    public int getMin() {
        return (int)min;
    }
}

方法五：
使用 Node 数据结构，在每一个 Node 结点中有一个属性记录最小值。

class MinStack5 {
    private Node head;

    public void push(int x) {
        if(head == null) 
            head = new Node(x, x);
        else 
            head = new Node(x, Math.min(x, head.min), head);
    }

    public void pop() {
        head = head.next;
    }

    public int top() {
        return head.val;
    }

    public int getMin() {
        return head.min;
    }

    private class Node {
        int val;
        int min;
        Node next;

        private Node(int val, int min) {
            this(val, min, null);
        }

        private Node(int val, int min, Node next) {
            this.val = val;
            this.min = min;
            this.next = next;
        }
    }
}