随笔：设计一个栈结构，使得取出栈中最大值时间复杂度为O(1)

题意：设计一个数据结构，符合栈的特点，即“后进先出”，且加多一个要求，使得取出该栈所有元素最大值的时间复杂度可以控制为O(1)。

说个很明显的错误，使用一个辅助变量，保存当前最大值，每次入栈的值都与该最大值比较，大则替换为最大值。

这样取出最大值则返回该辅助变量，很显然这个只能实现一次正确返回。

总体实现很简单，就是开辟多一个存储最大值索引的栈，该栈和存储数据的栈保持同步，即栈顶指针同时作用这两个栈。

代码也很简单，所以就不解释。

java代码如下：

public class MaxNumFromStack {
public static void main(String[] args) {
MyStack stack=new MyStack();
stack.push(2);
stack.push(3);
stack.push(4);
stack.push(5);
stack.push(1);
stack.push(10);
stack.push(8);
for(int i=0;i<6;i++){
System.out.println("TheNum:"+stack.pop());
System.out.println("MaxNum:"+stack.getMax());
System.out.println("=========================");
}
}
}
class MyStack{
private int top;
private int maxIndex;
private int MAX;
private int[] data;
private int[] maxStackIndex;
public MyStack(){
MAX=10;
top=-1;
maxIndex=-1;
data=new int[MAX];
maxStackIndex=new int[MAX];
}
//入栈
public void push(int num){
top++;
if(top>=MAX){
System.out.println("栈已满，不能入栈");
return;
}
data[top]=num;//先添加到栈中
if(num>getMax()){//大于当前最大值
maxStackIndex[top]=top;//当前是最大值
maxIndex=top;
}else{
//保留最大的值
maxStackIndex[top]=maxIndex;
}
}
//出栈
public int pop(){
if(top<0){
System.out.println("栈为空，不能出栈");
return Integer.MIN_VALUE;
}
int num=data[top];
if(top==0){
maxIndex=-1;
}else if(top==maxIndex){//当前栈顶是最大值,调整最大值
maxIndex=maxStackIndex[top-1];
}
top--;
return num;
}
public int getMax(){
if(maxIndex>=0){
return data[maxIndex];
}else{
//返回最小值
return Integer.MIN_VALUE;
}
}
}

输出：
TheNum:8
MaxNum:10
=========================
TheNum:10
MaxNum:5
=========================
TheNum:1
MaxNum:5
=========================
TheNum:5
MaxNum:4
=========================
TheNum:4
MaxNum:3
=========================
TheNum:3
MaxNum:2
=========================