關于棧和隊列的相關問題

#include<iostream>
using namespace std;
#include<stack>
#include<queue>
#include<assert.h>
//template<class T>
//兩個棧實現一個隊列
//class StackToqueue
//{
//public:
//	StackToqueue()
//	{}
//	void Push(const T& x)
//	{//始終保持讓棧1進
//		_stack1.push(x);
//	}
//	T Pop()
//	{
//		if (_stack2.empty() && !_stack1.empty())
//		{//如果棧2為空且棧1不為空，則將棧1的所有元素導入到棧2中，保證棧1進，棧2出
//			while (!_stack1.empty())
//			{
//				_stack2.push(_stack1.top());
//				_stack1.pop();
//			}
//		}
//		T StackPopElm = _stack2.top();
//		 _stack2.pop();
//		 return StackPopElm;
//	}
//	~StackToqueue()
//	{}
//protected:
//	stack<T> _stack1;
//	stack<T> _stack2;
//};
//
//void Test()
//{
//	StackToqueue<int> s;
//	s.Push(1);
//	s.Push(2);
//	s.Push(3);
//	s.Push(4);
//	s.Push(5);
//	s.Push(6);
//	s.Push(7);
//	s.Push(8);
//	s.Push(9);
//	s.Push(10);
//	cout << s.Pop() << " " <<endl;
//	cout << s.Pop() << " " << endl;
//	s.Push(11);
//	cout << s.Pop() << " " << endl;
//	cout << s.Pop() << " " << endl;
//}

//兩個隊列實現一個棧
//template<class T>
//class QueueToStack
//{
//public:
//	QueueToStack()
//	{}
//	void push(const T& x)
//	{//如果隊列1不為空則讓元素入到這個不為空的隊列中，若為空，默認入到隊列2中
//		if (!_queue1.empty())
//		{
//			_queue1.push(x);
//		}
//		else
//			_queue2.push(x);
//	}
//	T Pop()
//	{
//		if (_queue1.empty() && _queue2.empty())
//		{
//			return -1;
//		}
//		//如果-個隊列不為空，讓該隊列的前n-1個元素出隊列，放入到另一個隊列中
//		//讓該隊列中保持只有一個元素然后讓其出隊列
//		if (!_queue1.empty())
//		{
//			while (_queue1.front() && _queue1.front() != _queue1.back())
//			{
//				_queue2.push(_queue1.front());
//				_queue1.pop();
//			}
//			T QueuePopElm = _queue1.front();
//			_queue1.pop();
//			return QueuePopElm;
//
//		}
//		if (!_queue2.empty())
//		{
//			while (_queue2.front() && _queue2.front() != _queue2.back())
//			{
//				_queue1.push(_queue2.front());
//				_queue2.pop();
//			}
//			T QueuePopElm = _queue2.front();
//			_queue2.pop();
//			return QueuePopElm;
//		}
//	}
//	~QueueToStack()
//	{}
//protected:
//	queue<T> _queue1;
//	queue<T> _queue2;
//};

//void Test()
//{
//	QueueToStack<int> q;
//	q.push(1);
//	q.push(2);
//	q.push(3);
//	q.push(4);
//	q.push(5);
//	q.push(6);
//	q.push(7);
//	q.push(8);
//	cout << q.Pop() << " ";
//	cout << q.Pop() << " ";
//	cout << q.Pop() << " ";
//	q.push(9);
//	cout << q.Pop() << " ";
//	cout << q.Pop() << " ";
//}

//求一個棧中的最小元素
//template<class T>
//class StackMin
//{
//public:
//	StackMin()
//	{}
//	T GetStackMinTop()
//	{
//		return _stack_min.top();
//	}
//	void Push(const T&x)//兩個棧同時入元素，保存最小數的那個棧在入棧前先要與該棧頂元素相比較
//	{ //始終保持保存最小數的那個棧的棧頂元素是當前所有元素之中最小的
//		_stack.push(x);
//		if (_stack_min.empty())
//		{
//			_stack_min.push(x);
//		}
//		else
//		{
//			if (_stack_min.top() < x)
//			{
//				_stack_min.push(GetStackMinTop());
//			}
//			else
//			{
//				_stack_min.push(x);
//			}
//		}
//	}
//	void Pop()
//	{
//		if (!_stack.empty() && !_stack_min.empty())
//		{
//			_stack.pop();
//		    _stack_min.pop();
//		}
//	}
//protected:
//	stack<T> _stack;
//	stack<T> _stack_min;
//};
//
//void Test()
//{
//	StackMin<int> sm;
//	sm.Push(2);
//	sm.Push(8);
//	sm.Push(6);
//	sm.Push(9);
//	sm.Push(1);
//	sm.Push(5);
//	cout << sm.GetStackMinTop() << endl;
//	sm.Pop();
//	cout << sm.GetStackMinTop() << endl;
//	sm.Pop();
//	cout << sm.GetStackMinTop() << endl;
//	sm.Push(0);
//	cout << sm.GetStackMinTop() << endl;
//
//}
//判斷出棧順序的合法性
template<class T>
class Stack
{
public:
	Stack()
	{}
	bool IsLegal(const char* pushstr, const char* popstr)
	{
		assert(pushstr && popstr);
		if (strlen(pushstr) != strlen(popstr))
			return false;
		while (*pushstr || !_stack.empty())
		{//如果入棧序列不為空或者棧不為空
			_stack.push(*pushstr++);
			while(!_stack.empty()&&_stack.top()==*popstr)
			{//若棧不為空且棧頂元素與出棧序列元素相同，則出棧序列指針后移同時將棧頂元素出棧
				popstr++;
				_stack.pop();
			}	
			//如果入棧序列已為空且出棧序列元素不與棧頂元素匹配
			if (*pushstr == '\0' && !_stack.empty() && *popstr != _stack.top())
				return false;
		}
			return true;
	}
	~Stack()
	{}
protected:
	stack<T> _stack;
};

void Test()
{
	Stack<char> s;
	char* str = "12345";
	char* dst = "54321";
	cout << s.IsLegal(str, dst) << endl;
}