设计包含min函数的栈

题目：定义栈的数据结构，要求添加一个min函数，能够得到栈的最小元素，并且要求时间复杂度是O（1）。

思路：

1.如何找到一个栈中最小的元素，要遍历一遍（pop）确定最小元素后再push进去，但这个时间复杂度肯定不对。所以就要想增加空间复杂度来减少时间复杂度。

2.如果我用一个元素来记录最小元素，貌似可行，但是想到如果记录最小元素被pop出去后，怎么才能将最小元素指向第二小元素呢。所以O（1）的额外空间不够用啊，

所以需要一个O（n）的额外空间来记录。

3.因为我的栈是用动态数组实现的，所以我需要额外一个动态数组来记录当前esp下最大元素的index，然后在min函数中直接返回就行。

代码如下：

template <class T>
	class Stack{
	public:
		Stack():number(10),top(-1){
			storge = new T[number];
			minStorge = new int[number];
		}
		virtual ~Stack(){
			delete[] minStorge;
			delete[] storge;
		}
		void addStorge(int length=10){
			T* newStorge = new T[capicity+length];
			//这里千万不要使用memset，这样会把vitual ptr覆盖掉，如果T含有虚函数的话
			memcpy(newStorge,storge,capicity*sizeof(T));
			delete storge;
			storge = newStorge;

			int* newMinStorge = new int[capicity+length];
			memcpy(newMinStorge,minStorge,capicity*sizeof(int));
			delete minStorge;
			minStorge = newMinStorge;

			capicity = capicity+length;

		}
		T& pop() throw (char*){
			if (top<0)
			{
				throw "emepty stack";
			}

			return storge[top--];

		}
		void push(T& ele){
			if (top>=capicity)
			{
				addStorge();
			}
			top++;
			storge[top] = ele;

			if (top==0)
			{
				minStorge[0] = 0;
			}
			else{
				if (storge[top]<storge[minStorge[--top]])
				{
					minStorge[top] = top;
				}
				else{
					minStorge[top] =minStorge[--top];
				}
			}
			
		}
		const T& min() const throw (char *){
			if (top<0)
			{
				throw "emtpy stack";
			}
			return storge[minStorge[top]];
		}
	private:
		T* storge;
		int *minStorge;
		int capicity;
		int top;	
	};