两个栈实现一个队列及相关类型题

1.两个队列实现一个栈

栈是向下生长的，即数据遵循先进后出的规则。

队列是先进先出的，就像去超市买完东西结账，第一个到的先结账，后面到的排在队尾，数据只能从后面插，从前面读取

利用两个队列实现一个栈 ：

两个队列 q1和q2，q2为空

出栈：q1将123倒入q2，4从q1出来，就实现了1234，4先出来的栈的情形

然后在将q2数据123倒入q1，重复上述过程，即可完成数据出栈。

代码：

#include<iostream>  //两个栈实现一个队列
#include<stack>
#include<assert.h>
using namespace std;

template<class T>
class Stack_By_2Queue
{
public:
	void push(const T& data)
	{
		if (q1.size() > 1)
		{
			swap(q1, q2);//把原来的n-1个元素 给 q2  123 432
		}
		q1.push(data);
	}
	void pop()
	{
		assert(!q1.empty() || !q2.empty());
		if (!q1.empty())
		{
			std::swap(q1, q2);// 4321 1234
		}
		q2.pop();
	}
	T& top()
	{
		assert(!q1.empty() || !q2.empty());
		if (q1.empty())
		{
			std::swap(q1, q2);
		}
		return q1.top();
	}
	bool Empty()
	{
		return q2.empty() && q1.empty();
	}
	size_t size()
	{
		return q1.size() + q2.size();
	}
private:
	stack<T> q1;
	stack<T> q2;

};
 void test()
{
	 Stack_By_2Queue <int> s;
	 s.push(1);
	 s.push(2);
	 s.push(3);
	 s.push(4);
	 s.push(5);
	 while (!s.Empty())
	 {
		 cout << s.top() << endl;
		 s.pop();
	 }
//	 cout << s.push<< endl;

}
int main()
{
	test();
	system("pause");
	return 0;
}

2.两个栈实现一个队列

出队列：有两个栈s1,s2,刚开始数据1234压如s1，1在栈底最后pop，4在栈顶先pop，先将s1倒入s2,等到s1只剩下一个数据时pop s1,即数据1出栈，

然后再将q2倒入q1，重复上面的工作，数据1 2 3 4按序输出，实现了队列的先进先出。

源代码：

#include<iostream>
using namespace std;
#include<assert.h>
#include<queue>
template<class T>
class Queue_By_2Stack
{
public:
	void push(const T& data)//尾插
	{
		_s1.push(data);
	}
	void Pop()//头删
	{
		assert(!_s1.empty() || !_s2.empty());
		if (_s2.empty())//为空
		{
			while (_s1.size() > 0)
			{
				_s2.push(_s1.front());//1234 4321 1
				_s1.pop();
			}
		}
		_s2.pop();
	}
	T& Back()
	{
		assert(!_s1.empty() || !_s2.empty());
		if (_s1.empty())//s1为空
		{
			while (_s2.size() > 0)
			{
				_s1.push(_s2.top());//1234 4321 1
				_s2.pop();
			}
		}
		return _s1.top();
	}
	T& Front()
	{
		assert(!_s1.empty() || !_s2.empty());
		if (_s2.empty()) //s2为空
		{
			_s2.push(_s1.front());
			_s1.pop();
		}
		return _s2.front();
	}
	bool Empty()
	{
		return _s2.empty() && _s1.empty();//两个都为空
	}
private:
	queue<T> _s1;
	queue<T> _s2;
};
void test()
{
	Queue_By_2Stack<int> s;
	s.push(1);
	s.push(2);
	s.push(3);
	while (!s.Empty())
	{
		cout << s.Front() << endl;
		s.Pop();
	}
}
int main()
{
	test();
	system("pause");
	return 0;
}

3.实现一个栈Stack，要求实现Push（出栈）、Pop（入栈）、Min（返回最小值的操作）的时间复杂度为O(1)

存放数据2431

第一次：s1和s2为空，将数据1（2）push进s1和s2

第二次：将数据2（4）push进s1,如果数据2（4）比s2.top()小，将数据2（4）push进s2

如此循环，最后s1作为一个栈保存了所有数据，s2.pop（）返回数据的最小值

源代码：

#include<iostream>
#include<stack>
using namespace std;
typedef int T;
class StackMin

{
public:
	StackMin()
	{}
	~StackMin()
	{}
	void Push(T x)
	{
		s1.push(x);
		if (s2.empty() || x <= s2.top())
		{
			s2.push(x);
		}
	}
	void Pop()
	{
		if (s1.top() == s2.top())
		{
			s2.pop();
		}
		s1.pop();
	}
	T Min()
	{
		if (!s2.empty())
		{
			return s2.top();
		}
	}
	void Print()
	{
		while (!s1.empty())
		{
			cout << s1.top() << "->";
			s1.pop();
		}
		cout << endl;
		while (!s2.empty())
		{
			cout << s2.top() << "->";
			s2.pop();
		}
		cout << endl;
	}
private:
	stack<T> s1, s2;
};
void Test()
{
	StackMin s;
	s.Push(1);
	s.Push(2);
	s.Push(3);
	s.Push(4);
	s.Push(5);
	s.Push(6);
	s.Print();
}
int main()
{
	Test();
	system("pause");
	return 0;
}

4.判断一个栈的出栈序列是否合法，如入栈序列（1，2，3，4，5），出栈序列（4，5，3，2，1）合法，出栈序列（4，5，2，3，1）不合法

栈是“先进后出”的，如入栈序列为（1，2，3，4，5），想要出栈序列为（4，5，3，2，1）需要这么做：

第一次入栈：1，2，3，4     出栈：4

第二次

#include<iostream>
#include<stack>
using namespace std;
template <class T>
class Stack
{
public:
	bool Check(int stack_out[], T stack_in[], T len_in, T len_out)
	{
		if (len_in!= len_out || len_out == 0)
		{
			return 0;
		}
		size_t i = 0;
		size_t j = 0;
		while (j < len_out)
		{
			s.push(stack_out[i]);
			for (; i < len_in;i++)
			{
				if (stack_in[i] == stack_out[j])
				{
					s.pop();
					j++;
				}
				else
				{
					break;
				}
			}
			if (i == j)
			{
				return true;
			}
			else
			{
				return false;
			}
		}
		
	}
private:
	stack <int> s;
};
void test()
{
	Stack <int> s;
	int stack_in[] = { 1, 2, 3, 4, 5 };
	int stack_out[] = { 4, 5, 3, 2, 1 };
	int len_in = sizeof(stack_in) / sizeof(stack_in[0]);
	int len_out = sizeof(stack_out) / sizeof(stack_out[0]);
	int ret = s.Check(stack_in, stack_out, len_in, len_out);
	cout << "顺序？" << ret << endl;
}
int main()
{
	test();
	system("pause");
	return 0;
}

入栈：5                      出栈：5     出栈：3   出栈：2  出栈：1

其他情况以此类推

源代码：