实现一个栈的pop,push,Min(最小值)，时间复杂度为O(1)

我们实现这个栈功能: 出栈，入栈，找出栈栈中元素的最小值。

方法一：把两个数最为一个数据对，每次入栈，就放两个（每次把最小的数值放在栈顶）

代码如下：

//方法一：把两个数据 作为 一个数据对 
template<class T>
class MinStack
{
public:
	MinStack(){}
	void push(const T& data)
	{
		if (_s.empty() || data <= _s.top())  //传进来的数小 栈顶元素
		{
			_s.push(data);
			_s.push(data);
		}
		else  //传进来的数字 大于  栈顶元素
		{
			T Mindata = _s.top();//  保存最小值
			_s.push(data);
			_s.push(Mindata);   //最小值放在 栈顶 
		}
	}
	void pop()
	{
		assert(!_s.empty());
		_s.pop();
		_s.pop();
	}
	T Min()const
	{
		return _s.top();
	}
	T& top()
	{
		assert(!_s.empty());
		T mindata = _s.top();
		_s.pop();
		T&  Ret = _s.top();  /////!!!T的引用类型 ， 因为返回类型是T& 
		_s.push(mindata);
		return Ret;
	}
private:
	stack<T> _s;
};

还是把检测韩式写上去吧，检测函数（用的时候，直接把函数名改为main）：

int Funtest1() 
{
	MinStack<int> S;
	S.push(1);
	S.push(1);
	S.push(2);
	S.push(0);
	cout << S.top() << endl; //0
	int ret = S.Min();//0
	/* S.Min() = 3;*/  //还是不要修改的好
	S.pop();
	S.pop();
	cout << S.top() << endl;//1
	S.push(3);
	S.push(1);
	ret = S.Min();//1
	cout << S.top() << endl;//1
	return 0;
}

方法二其实就是方法一的演进，只是看起来整齐点。

方法二：用结构体把两个数据存放在一起，在传给栈。

template<class T>
class MinStackByStruct
{
public:
	void push(const T& data)
	{
		
		if ( _s.empty() || data<= _s.top()._SecondData)
		{
			DoubleData<T> _Data(data,data);
			_s.push(_Data);
		}
		else  //传进来的数大
		{
			DoubleData<T> DataElem(data, _s.top()._SecondData);
			_s.push(DataElem);
		}
	}

	void Pop()
	{
		assert(!_s.empty());
		_s.pop();
	}
	T Min()
	{
		return _s.top()._SecondData;
	}
	T Top()
	{
		return _s.top()._FirstData;
	}
private:
	template<class T>
	struct DoubleData
	{
		DoubleData(const T& FirstData , const T& SecondData)
		:_FirstData(FirstData)
		, _SecondData(SecondData)
		{}
		T _FirstData;
		T _SecondData;
	};   

	stack<DoubleData<T> > _s ;  //传参为 结构体！！！
};

方法三：使用两个栈，一个栈用来存放数据，一个栈用来存放最小值

template<class T>
class MinStack_By_2Stack
{
public:
	void push(const T& data)
	{
		if (_s1.empty() ||_s2.top() >= data )// s1为空 || s2栈顶更小
		{
			_s1.push(data);
			_s2.push(data);
		}
		else
		{
				_s1.push(data);
		}
	}
	void Pop()
	{
		assert(!Empty());
		if (_s1.top() == _s2.top()) //相等的时候在 同时出栈
		{
			_s1.pop();
			_s2.pop();
		}
		else
		{
			_s1.pop();
		}
	}
	T Min()
	{
		assert(!Empty());
		return _s2.top();
	}

	T& Top()
	{
		assert(!Empty());
		return _s1.top();
	}
	bool Empty()
	{
		return _s1.empty();
	}
private:
	stack<T> _s1; //存数据
	stack<T> _s2; //存最小值
};