设计一个堆栈，函数min、push 以及pop 的时间复杂度都是O(1)

/**
 * 2.设计包含min 函数的栈。
 *  定义栈的数据结构，要求添加一个min 函数，能够得到栈的最小元素。
 *  要求函数min、push 以及pop 的时间复杂度都是O(1)。
 *  
 *  经典的空间换取时间，这个是利用java语言的JDK的实现的
 */
public class A02_1 {
	 public static void main(String[] args){
		    StackA stack = new StackA();
		    stack.push(1);
		    System.out.println(stack.min());
		    stack.push(3);stack.push(0);
		    System.out.println(stack.size());
		    System.out.println(stack.min());
		    stack.pop();
		    System.out.println(stack.min());
		}
		static class StackA extends Vector<Integer>{
		   
		    private static final long serialVersionUID = -2638250013215651059L;
		    //最小值的栈，用来存储最小的值的下标
		    public Stack<Integer> minstack = new Stack<Integer>();
		   
		    /**
		    * 取的最小值
		    * */
		    public Integer min(){
		    	//最小值的下标，得到这个最小值
		        return super.get(minstack.peek());
		    }
		    public void push(Integer interger){
		        if(super.size() == 0){
		           minstack.push(0);
		        }else{
		        	
		           if(interger.compareTo(min())<= 0){
		        	 //如果压栈的这个值比最小值小
		               minstack.push(super.size());
		           }else{
		        	 //如果压栈的这个值比最小值大，还是原来的最小值对应的那个坐标
		               minstack.push(minstack.peek());
		           }
		        }
		        super.add(interger);
		    }
		   
		    public Integer pop(){
		        if(0 == super.size())
		           throw new EmptyStackException();
		        Integer result = super.get(super.size()-1);
		        super.remove(super.size() - 1);
		        //与之相对应的最小值的出栈
		        minstack.pop();
		        return result;
		    }
		}

}

//第二种的方法，更加的清晰说明空间换取时间

public class A02_2 {
	
    public  static void main(String[] args){
    stack name = new stack();
    name.push(5);
    System.out.println(name.min());
    name.push(2);name.push(6);//5 2 6
     System.out.println(name.min());
    name.pop();//5 2
    System.out.println(name.min());
    name.push(1);name.push(1);name.push(0);//5 2 1 1 0
    System.out.println(name.min());
    name.pop();name.pop();//5 2 1
    System.out.println(name.min());
     name.pop();name.pop();//5
    System.out.println(name.min());    
    }
static class element{
	//当前元素的内容
    public int content;
    //其对用的最小值
    public int minvalue;
    public element(int value){
        content = value;
    }
}
static class stack{
    private static final int MAX = 10;
    element[] array =new element[MAX];
    int top = -1;
    public int pop(){
        if(top < 0){
           throw new Error("null array");
        }
        int result = array[top].content;
        array[top] = null;
        top--;
        return result;
    }
    public void push(int value){
        element temp = new element(value);
        if(top < 0){ 
           temp.minvalue = value;
        }else{
           if(value <= min()){
        	   //压栈元素小于最小的元素
               temp.minvalue = value;
           }else{
               temp.minvalue = min();//
           }
        }
        top++;
        array[top] = temp;
    }
    public int min(){
        if(top < 0){
           throw new Error("null array");
        }
        return array[top].minvalue;
    }
}
}