假设给出一组数字，我们需要在O(1)时间复杂度内完成对这组数字最小值的求解。

题目具体描述：定义一个栈，请在该类型中实现一个能够得到栈的最小值元素的min函数。在该栈中，调用min，

push和push的时间复杂度都是O(1).

下边给出两种方法：

方法一：采用辅助栈实现

实现过程描述：辅助栈专门用来存储当前数据栈中的元素的最小值。

当数据栈中push进第一个元素，该元素也得进辅助栈；

当数据栈中再次push进元素，该元素如果小于辅助栈中的最上边的元素，将该元素push进辅助栈；

否则，那就是，新push进的元素大于辅助栈的最上边的元素，此时，辅助栈的最上边的元素再次入栈。

下边给出实现代码：

#include<iostream>
using namespace std;
template<typename T>
class Stack
{
public:
	Stack()
		:_data(NULL),_min(NULL),_size(0),_capacity(0)
	{}
	~Stack()
	{
		delete[] _data;
		delete[] _min;
		_data = NULL;
		_min = NULL;
		_size = 0;
		_capacity = 0;
	}
	void Push(const T& x)
	{
		CheckCapacity();
		_data[_size] = x;
		//++_size;
		if (x < _min[_size - 1] || _size == 0)
		{
			_min[_size] = x;
		}
		else
		{
			_min[_size] = _min[_size - 1];
		}
		++_size;
	}
	void Pop()
	{
		if (_size > 0)
		{
			--_size;
		}
	}
	size_t Min()
	{
		return _min[_size - 1];
	}
protected:
	void CheckCapacity()
	{
		if (_size >= _capacity)
		{
			size_t NewCapacity = 2 * _capacity + 5;
			T* tmp1 = new T[NewCapacity];
			T* tmp2 = new T[NewCapacity];
			//拷贝内容
			for (size_t i = 0; i < _size; ++i)
			{
				tmp1[i] = _data[i];
			}
			delete[] _data;
			_data = tmp1;
			for (size_t i = 0; i < _size; ++i)
			{
				tmp2[i] = _min[i];
			}
			delete[] _min;
			_min = tmp2;

			_capacity = NewCapacity;
		}
	}
private:
	T* _data;
	T* _min;
	size_t _size;
	size_t _capacity;
};
void test()
{
	Stack<int> s;
	s.Push(3);
	s.Push(4);
	s.Push(2);
	s.Push(1);
	cout << s.Min() << endl;
	s.Push(0);
	cout << s.Min() << endl;
}
int main()
{
	test();
	system("pause");
	return 0;
}

当然，其实我们没有必要将最小值保存多份~~这样实现起来估计就是稍微难控制一些~两个栈都需要有自己的size和

capacity，这个，可以自己实现。

方法二：将比较小的元素入栈两次

实现过程：开始将第一个元素入栈两次。

之后，如果一个元素小于栈顶元素，入栈两次；如果大于栈顶元素，将新的元素放在栈顶元素的下边（拿出栈顶元

素，放进新元素，最终放进原栈顶元素）

下边给出实现代码：

#include<iostream>
using namespace std;
#include<stack>
template<typename T>
class Stack
{
public:
	Stack(T arr[],int size)
		:_arr(arr),_size(size)
	{}
	T Min()
	{
		int i = 0;
		stack<int> s;
		s.push(_arr[0]);
		s.push(_arr[0]);
		for (i = 1; i < _size; ++i)
		{
			if ((s.empty()) || (s.top() > _arr[i]))
			{
				s.push(_arr[i]);
				s.push(_arr[i]);
			}
			else
			{
				int min = s.top();
				s.pop();
				s.push(_arr[i]);
				s.push(min);
			}
		}
		return s.top();
	}
	T& Top()
	{
		return _arr[_size - 1];
	}

private:
	T* _arr;
	int _size;
};
void test()
{
	int arr[7] = { 2,3,1,4,5,-3 };
	Stack<int> Arr(arr,7);

	cout << Arr.Min() << endl;
}
int main()
{
	test();
	return 0;
}

这种方法实现起来也是比较简单，但是栈是静态的，如果实现成动态或许会不错~~不过，第一种方法已经实现过了动

态栈，这里就不会给出了~~~