1.实现一个栈，要求实现push，pop，Min（返回最小值的操作）的时间复杂度为O（1）

算法思想：需要设计一个辅助栈，用来存储当前栈中元素的最小值。额外需要注意push操作，第一个元素不用比较，自动成为最小值入栈，其他元素每次都要和栈顶元素进行比较，小的入栈。 

#include<iostream>

#include<stack>      //直接用系统中的栈，不需要自己实现

using namespace std;

template<class T>

class Stack

{

public:

void push(const T& x)

{

_stack.push(x);

if (_minstack.empty()) 

{

_minstack.push(x);

}

else

{

if (x < _minstack.top())

{

_minstack.push(x);

}

else

{

_minstack.push(_minstack.top());

}

}

}

void pop()

{

_stack.pop();

_minstack.pop();

}

T Retmin()

{

return _minstack.top();

}

private:

stack<T> _stack;

stack<T> _minstack;

};

void test()

{

Stack<int> s;

int ret;

s.push(3);

s.push(2);

s.push(5);

s.push(1);

s.push(7);


s.pop();

s.pop();

ret = s.Retmin();

cout << "最小值是:" << ret << endl;

}


int main()

{

test();

return 0;

}

2.元素出栈入栈顺序的合法性检查

算法思想：用for循环将数组1中的元素入栈，每入栈一个与数组2中当前元素进行进行比较，如果相同就出栈，数组2中下一个元素作为当前元素。如果循环结束，而栈中还有元素，就说明数组2不是pop序列。

#include<iostream>

#include<stack>

using namespace std;

bool InvalidCheck(int* stack_in, int* stack_out, int len1, int len2)

{

stack<int> s;

if (len1 != len2)

{

return false;

}

int i = 0, j = 0;

for (i = 0, j = 0; i < len1; i++)

{

s.push(stack_in[i]);

while (s.size()>0 && s.top() == stack_out[j])

{

s.pop();

j++;

}

}

if (s.size() > 0)

return false;

else

return true;

}

int main()

{

int stack_in[] = { 1, 2, 3, 4, 5 };

int stack_out[] = { 4, 5, 1, 2, 3 };

int len1 = sizeof(stack_in) / sizeof(stack_in[0]);

int len2 = sizeof(stack_out) / sizeof(stack_out[0]);

bool ret = InvalidCheck(stack_in, stack_out, len1, len2);

if (ret)

{

cout << "出栈顺序合法!" << endl;

}

else

{

cout << "出栈顺序不合法!" << endl;

}

return 0;

}