面试题21：包含min函数的栈

题目：定义栈的数据结构，要求添加一个min函数，能够得到栈的最小元素。要求函数min、push以及pop的时间复杂度都是O(1)。定义栈的数据结构，要求添加一个min函数，能够得到栈的最小元素。要求函数min、push以及pop的时间复杂度都是O(1)。

思路：定义一个辅助栈，辅助栈的栈顶为当前栈中的最小值。

入栈：第一个元素入栈的时候将元素也压入辅助栈，因为当前栈中只有一个元素，这个元素就是当前最小值，之后的元素入栈的时候与辅助栈的栈顶元素比较，如果小于或等于(必须要有等于)辅助栈栈顶元素，将此元素压入辅助栈。

出栈：出栈先判断栈是否为空，不为空将栈顶元素与辅助栈顶元素比较，如果不相等直接出栈，如果相等，将辅助栈的栈顶元素也出栈。

C++版：

#include <iostream>
#include <vector>
#include <cassert>

using namespace std;

template<typename T>
class StackMin
{
public:
  vector<T> stack;
  vector<T> minStack;

  //压栈
  void push(T data)
  {
    stack.push_back(data);
	//如果最小值栈为空，或者要压栈的元素的值小于或等于栈中的最小值
    if (minStack.empty() || data <=minStack.back())
	{
		 minStack.push_back(data);//将元素压入最小值栈
	}
     
  }

  void pop()
  {
    assert(!stack.empty());//如果栈不为空
    if (stack.back() == minStack.back())
	{
		minStack.pop_back();
	}
    stack.pop_back();
  }

  T min()
  {
    assert(!stack.empty() && !minStack.empty());
    return minStack.back();
  }

  void display()
  {
    cout << "datas = ";
	int i;
    for (i = 0; i < stack.size(); i ++)
      cout << stack[i] << " ";
    cout << endl;
    cout << "minStack = ";
    for (i = 0; i < minStack.size(); i ++)
      cout << minStack[i]<< " ";
    cout << endl;
    cout << "min = " << minStack.back() << endl << endl;
  }
};
int main()
{
  StackMin<int> s;
  s.push(3);
  s.display();
  s.push(3);
  s.display();
  s.push(2);
  s.display();
  s.push(0);
  s.display();
  s.pop();
  s.display();
  s.pop();
  s.pop();
  s.display();
  return 0;
}

参考：http://www.cnblogs.com/likwo/archive/2010/12/21/1912331.html

Java版:

public class StackTest {

	public static void main(String[] args) {
		MinStack stack=new MinStack();
		stack.push(1);
		stack.push(0);
		stack.push(1);
		stack.pop();
		stack.pop();
		System.out.println(stack.minInStack());
	}

	public static class MinStack
	{
		private Stack<Integer> stack=new Stack<Integer>();
		private Stack<Integer> minStack =new Stack<Integer>();
		
		public void push(int data)
		{
			//如果栈为空，说明此时只有一个元素，先将元素压入最小值栈
			if(stack.empty())
			{
				minStack.push(data);
			}
			else//如果不为空，判断当前元素和最小值栈顶元素哪个大
			{
				if(data<=minStack.peek())//如果小于或等于栈顶元素
				{
					minStack.push(data);//将元素压入最小值栈
				}
			}
			//元素压栈
			stack.push(data);
		}
		
		public void pop()
		{
			if(!minStack.empty()&&!stack.empty())
			{
				//如果要出栈的值与最小值栈顶元素相同，同时出栈
				if(stack.peek()==minStack.peek())
				{
					stack.pop();
					minStack.pop();
				}
				else
				{
					stack.pop();
				}
			}
			
		}
		
		public Integer minInStack()
		{
			if(!minStack.empty())
			{
				return minStack.peek();
			}
			else
			{
				return null;
			}
		}
	}
}