剑指offer-定义栈的数据结构，请在该类型中实现一个能够得到栈最小元素的min函数。

包含min函数的栈
定义栈的数据结构，请在该类型中实现一个能够得到栈最小元素的min函数。

思路：
借助一个辅助栈minStack，与原始栈的大小一样。
初始时为原始栈的第一个元素，然后依次比较，如果原始栈中有比minStack栈顶元素小的元素就直接入栈，如果没有则把minStack栈顶元素重新入栈

public class StackMinElementSolution {

    private Stack<Integer> originalStack=new Stack<Integer>();  
    private Stack<Integer> minStack=new Stack<Integer>();

    //进栈
    public void push(int node) {
        //如果最小栈为空，直接进栈
        //如果最小栈的栈顶元素大于等于当前元素，直接进栈
        if(minStack.isEmpty() || minStack.peek()>=node)
        {
            minStack.push(node);
        }else {
            //如果最小栈的栈顶元素小于当前元素，则把最小栈的栈顶元素再次进栈
            minStack.push(minStack.peek());

        }
        originalStack.push(node);
    }

    //出栈
    public void pop() {
        if(originalStack.isEmpty() || minStack.isEmpty())
        {
            return;
        }
        originalStack.pop();
        minStack.pop();  
    }

    //弹出栈顶元素
    public int top() {
        if(!originalStack.isEmpty())
        {
            return originalStack.peek();
        }
        return 0;
    }

    public int min() {
        if(!minStack.isEmpty())
        {
            return minStack.peek();
        }
        return 0;
    }
}

其他方法
不借助辅助栈，push(),pop(),top()使用stack的方法
对于min()，借助一个变量，顺次比较栈中的元素

public int min() {
        int min = stack.peek();
        int tmp = 0;
        Iterator<Integer> iterator = stack.iterator();
        while (iterator.hasNext()){
            tmp = iterator.next();
            if (min>tmp){
                min = tmp;
            }
        }
        return min;
    }