第四十五题 包含min函数的栈

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

思路：在栈里添加一个成员变量存放最小元素（或最小元素的位置）。每次push一个新元素进栈的时候，如果该元素比当前的最小元素还要小，则更新最小元素。

乍一看这样思路挺好的。但仔细一想，该思路存在一个重要的问题：如果当前最小元素被pop出去，如何才能得到下一个最小元素？

因此仅仅只添加一个成员变量存放最小元素（或最小元素的位置）是不够的。我们需要一个辅助栈。每次push一个新元素的时候，同时将最小元素（或最小元素的位置。考虑到栈元素的类型可能是复杂的数据结构，用最小元素的位置将能减少空间消耗）push到辅助栈中；每次pop一个元素出栈的时候，同时pop辅助栈。

举个例子演示上述代码的运行过程：

  步骤              数据栈            辅助栈                最小值
1.push 3    3          0             3
2.push 4    3,4        0,0           3
3.push 2    3,4,2      0,0,2         2
4.push 1    3,4,2,1    0,0,2,3       1
5.pop       3,4,2      0,0,2         2
6.pop       3,4        0,0           3
7.push 0    3,4,0      0,0,2         0

头文件：

#include <iostream>
#include <assert.h>
#include <stack>
using namespace std;
template <typename T>
class StackMin
{
public:
	StackMin(){}
	~StackMin(){}
	void pop();
	void push(const T&);
	const T& top()const;
	const T& min()const;
	bool empty()const;
	size_t size()const;
private:
	stack<T> origin;
	stack<T> mindata;
};
template <typename T>
void StackMin<T>::pop()
{
	if (origin.size()>0&&mindata.size()>0)
	{
		origin.pop();
		mindata.pop();
	}
}
template <typename T>
void StackMin<T>::push(const T&value)
{
	origin.push(value);
	if (mindata.size()==0||value<mindata.top())
	{
		mindata.push(value);
	}
	else
	{
		mindata.push(origin.top());
	}
}
template <typename T>
const T& StackMin<T>::top()const
{
	if (origin.size()>0)
	{
		return origin.top();
	}
}
template <typename T>
const T& StackMin<T>::min()const
{
	assert(mindata.size()>0&&origin.size()>0);
	return mindata.top();
}
template <typename T> bool StackMin<T>::empty() const
{
	return origin.empty();
}

template <typename T> size_t StackMin<T>::size() const
{
	return origin.size();
}

cpp文件：

#include "stackmin.h"
int main()
{
	StackMin<int> stackmin;
	stackmin.push(3);
	stackmin.push(4);
	stackmin.push(2);
	stackmin.push(1);
	cout<<stackmin.min()<<endl;
	stackmin.pop();
	stackmin.pop();
	stackmin.push(0);
	cout<<stackmin.min();
	return 0;
}