剑指Offer：包含min函数的栈

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

看到这个问题我们的第一反应是每压入一个元素就对栈中的元素进行排序，让最小的元素位于栈顶，这样就能在O(1)时间得到最小元素了。但是，这种方法可能会违背了栈先进后出的原则，那么这种类型就不是栈结构了。舍去这种方法。

那我们在栈结构中声明一个变量，每次压入新的元素时就和它比较，如果新元素比它小则更新这个变量。可是这种方法缺陷特别大，如果我们已经将这个最小元素弹出栈了，我们调用min函数得到的还是原来的最小元素，实际上是次小的元素。

我们不仅仅要保留最小的还要保留次小的，还要保留次次小的，无穷无尽有木有，用变量的方法肯定是不可以了。我们可以创建一个辅助栈，每次我们压入一个新的元素时我们就将最小的值压入栈中。

操作流程如图所示：



代码实现：

Stack栈结构的实现：

public class Stack {
int[] stack;
int size;
int nitems;
private AssistStack assistStack;//辅助栈

public Stack(){}
public Stack(int size){
this.size = size;
stack = new int[size];
nitems = 0;
assistStack = new AssistStack(size);
}

public boolean isFull(){
return nitems==size;
}

public boolean isEmpty(){
return nitems==0;
}

public Integer Pop(){
if(isEmpty()){
System.out.println("Stack is empty!");
return null;
}
assistStack.Pop();
nitems--;
return stack[nitems];
}

public void Push(int num){
if(isFull()){
System.out.println("Stack is full!");
}
if(isEmpty()){
assistStack.Push(num);//第一次入栈的元素就是最小的元素
}
if(num<assistStack.Top()){
assistStack.Push(num);
}else{
assistStack.Push(assistStack.Top());
}
stack[nitems] = num;
nitems++;
}

public int Top(){
return stack[nitems-1];
}
public int size(){
return nitems;
}

public int min(){
return assistStack.Top();
}
}

辅助栈：

public class AssistStack extends Stack{
public AssistStack(int size) {
this.size = size;
this.nitems = 0;
this.stack = new int[size];
}

@Override
public void Push(int num) {
if(isFull()){
System.out.println("Stack is full!");
}
stack[nitems] = num;
nitems++;
}

@Override
public Integer Pop() {
if(isEmpty()){
System.out.println("Stack is empty!");
return null;
}
nitems--;
return stack[nitems];
}
}