包含min函数的栈（栈）

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

思路一：

*用一个数组data保存数据，用一个栈minStack保存依次入栈最小的数

*若data中依次存入：5，4，3，8，10，11，12，1

       则min依次入栈：5，4，3，3，3，3，3，1

*每次入栈的时候，如果入栈的元素 <= min中的栈顶元素，则入栈该元素，否则入栈当前的min。

import java.util.Arrays;
import java.util.Stack;

public class Solution {
    private Stack<Integer> minStack = new Stack<>();
    private Integer[] data = new Integer[10];

    private int size;
    private int min = Integer.MAX_VALUE;

    //数组长度扩展
    private void ensureCapacity(int size)
    {
        int len = data.length;
        if (size > len)
        {
            int newLen = len * 2 + 1;
            data = Arrays.copyOf(data, newLen);
        }
    }

    public void push(int node) {
        ensureCapacity(size + 1);
        data[size++] = node;
        if (node <= min)
        {
            minStack.push(node);
            min = minStack.peek();
        }
        else
            minStack.push(min);
    }

    public void pop() {
        Integer top = top();
        if (top != null) data[size - 1] = (Integer) null;
        size--;
        minStack.pop();
        min = minStack.peek();
    }

    public int top() {
        if (size > 0) return data[size - 1];
        else return (Integer) null;
    }

    public int min() {
        return min;
    }
}

思路二：

*用一个栈data保存数据，用另外一个栈min保存依次入栈最小的数

*若data中依次入栈：5，4，3，8，10，11，12，1

       则min依次入栈：5，4，3，no，no，no，no，1（no代表此次不入栈）

*每次入栈的时候，如果入栈的元素 <= min中的栈顶元素，则入栈，否则不入栈。

import java.util.Stack;

public class Solution {
    Stack<Integer> min = new Stack<>();
    Stack<Integer> data = new Stack<>();
    Integer temp = null;

    public void push(int node) {
        if (temp != null)
        {
            if (node <= temp)
            {
                temp = node;
                min.push(node);
            }
            data.push(node);
        }
        else
        {
            temp = node;
            data.push(node);
            min.push(node);
        }
    }

    public void pop() {
        int num = data.pop();
        int num2 = min.pop();
        if (num != num2) min.push(num2);
    }

    public int top() {
        int num = data.pop();
        data.push(num);
        return num;
    }

    public int min() {
        int num = min.pop();
        min.push(num);
        return num;
    }
}