栈在o(1)时间获取最小元素

pop,push里面都为o(1)，这里只有时间复杂度的要求，但是没有空间复杂度的要求:

思路1：原来的栈里面只有一个数组，来存放所有的push值，现在，多一个用来存放最小值得栈，如果新进元素的值比最小值栈里面栈顶的元素要小，就push到最小值栈，其它情况不变。

思路2：将放数据的单独列出，放在一个类里面，每一个数据都知道最小值是什么。

思路一代码：

class StackOfMine{
 int[] elems=null;//数据放在这里
 int[] min=null;
 public StackOfMine(int k){
   elems=new int[k];
   min=new int[k];
 }
 int topOfStack=-1;
 int topOfMinStack=-1;
 public boolean isEmpty(){
   return topOfStack==-1;
 }
 public boolean isFull(){
  return topOfStack==elems.length;
 }
 public int getMin(){
  return getTopElem();
 }
 public int getTopElem(){
  return min[topOfMinStack];
 }
 public void push(int a){
  topOfStack++;
  if (!isFull()) {
  elems[topOfStack]=a;
  if (topOfStack==0) {
  topOfMinStack++;
  min[topOfMinStack]=a;
  }else{
  if (a<getTopElem()) {
  topOfMinStack++;
  min[topOfMinStack]=a;
  }
  }
  }else{
  throw new Error("wrong");
  }
 }
 public int pop(){
  int temp=elems[topOfStack];
  topOfStack--;
  if (temp==getTopElem()) {
  topOfMinStack--;
  }
  return temp;
 }
}

//思路2代码

class MyStack{
Elem[] a;//数据单独放在一个地方
public MyStack(int k){
a=new Elem[k];
for (int i=0;i<k ;i++ ) {
a[i]=new Elem();
}
}
int topOfStack=-1;
public void push(int b){
     topOfStack++;
     Elem temp=a[topOfStack];
     temp.setData(b);
     temp.setMin(topOfStack==0?b:(b>a[topOfStack-1].getMin()?a[topOfStack-1].getMin():b));
}
public int pop(){
int temp=a[topOfStack].getData();
topOfStack--;
return temp;
}
public int getMin(){
return a[topOfStack].getmin();
}
}
class Elem{
         private int data;
 private int min;
public void setData(int d){
data=d;
}
public void setMin(int m){
min=m;
}
public int getmin(){
return min;
}

       public int getData(){

              return data;

        }
}