剑指offer:包含min函数的栈(java)

题目：定义栈的数据结构，请在该类型中实现一个能够得到栈的最小元素的min函数。在该栈中，调用min，push及pop的时间复杂度都是O(1).

    看到这个问题，我们的第一反应可能是每次压入一个新元素进栈时，将栈里的所有元素排序，让最小的元素位于栈顶，这样就能在O(1)时间得到最小元素了。但这种思路不能保证最后压入的元素能够最先出栈，因此这个数据结构已经不是栈了。

    我们接着想到在栈里添加一个成员变量存放最小的元素。每次压入一个新元素进栈的时候，如果该元素比当前最小的元素还要小，则更新最小元素。面试官听到这种思路之后就会问：如果当前最小的元素被弹出栈了，如何得到下一个最小的元素呢？

    分析到这里我们发现仅仅添加一个成员变量存放最小元素是不够的，也就是说当最小元素弹出栈的时候，我们希望能够得到次小元素。因此在压入这个最小元素之前，我们要把次小元素保存起来。因此，在压入这个最小元素之前，我们要把次小元素保存起来。因此我们可以把每次的最小元素都保存起来放到另一个辅助栈里。

    我们不妨举几个例子来分析一下把元素压入或者弹出栈的过程。

    从表4.1我们可以看出，如果每次都把最小元素压入辅助栈，那么就能保证辅助栈的栈顶一直都是最小元素。当最小元素从数据栈内弹出之后，同时弹出辅助栈的栈顶元素，此时辅助栈的新栈顶元素就是下一个最小值。

class ListNode<K>{  
    K data;  
    ListNode<K> nextNode;  
}  
public class MyStack<K> {  
    /** 
     * 定义栈的数据结构，请在该类型中实现一个能够得到栈的最小元素的min函数 
     * 在该栈中，min、push、pop的时间复杂度都是O(1) 
     */  
    public ListNode<K> head;  
    public int length;  
    public void push(K item){  
        ListNode<K> node = new ListNode<K>();  
        node.data = item;  
        node.nextNode = head;  
        head = node;  
        length++;  
    }  
    public K pop(){  
        if(head == null)  
            return null;  
        ListNode<K> temp = head;  
        head = head.nextNode;  
        length--;  
        return temp.data;  
    }  
      
}  

private MyStack<Integer> minStack = new MyStack<>();  
private MyStack<Integer> dataStack = new MyStack<>();  
public void push(Integer item){  
        dataStack.push(item);  
        if(minStack.length == 0 || item<=minStack.head.data){  
            minStack.push(item);  
        }else{  
            minStack.push(minStack.head.data);  
        }  
    }  
    public Integer pop(){  
        if(dataStack.length == 0 || minStack.length == 0){  
            return null;  
        }  
        minStack.pop();  
        return dataStack.pop();  
    }  
    public Integer min(){  
        if(minStack.length == 0){  
            return null;  
        }  
        return minStack.head.data;  
    }