实现一个栈的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; //存最小值
};