随笔：设计一个栈结构，使得取出栈中最大值时间复杂度为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
=========================