两个栈实现一个队列&两个队列实现一个栈

这两个题的思路比较相似。

栈的特点是“先进后出”，队列的特点是“先进先出”。

不要怕！用两个栈实现一个队列很简单,push的时候我们都push到stack_1里面，当我们要pop的时候，要找到最先push进去的，此时stack_2为空，我们取stack_1的top元素，

再将top元素push到stack_2中，然后将stack_1 pop一次直到stack_1剩下最后一个元素，这个就是最先push进去的，我们把它pop掉就可以了，同理，我们求queue的front元素时，

用的方法和pop相同。主要思想就是这样，下来你们看一下代码，我已经测试过了

class My_Queue
{
public:
	My_Queue()
	{
		_size=0;
	}
	bool empty()
	{
		if(_size==0)
			return true;
		else
			return false;
	}
	void push(int data)//不论什么情况我们都把它push到第一个栈里
	{
		_s1.push(data);
		_size++;
	}
	void pop()
	{
		int tmp=0;
		if(_s1.size()==0&&_s2.size()==0)
		{
			printf("queue is empty!\n");
			return;
		}
		else
		{//pop的时候只有一种特殊情况需要处理，就是当第二个栈为空，我们要把第一个栈里的元素都push到第二个栈里，这样来实现元素顺序的翻转
			if(_s2.empty())
			{
				while(!_s1.empty())
				{
					tmp=_s1.top();
					_s2.push(tmp);
					_s1.pop();
				}
				_s2.pop();
				_size--;
			}
			else //走到这里s2一定不为空，即使s1里有元素，那也是之后push进去的，而且s2里的top就是先push进去的
			{
				_s2.pop();
				_size--;
			}
		}
	}
	int top()
	{
		assert((!_s1.empty())||(!_s2.empty()));
		
			int tmp=0;
			if(_s1.empty())
				return _s2.top();
			if(_s2.empty())
			{
				while(!_s1.empty())
				{
					tmp=_s1.top();
					_s2.push(tmp);
					_s1.pop();
				}
			}
			return _s2.top();
	}
	int size()
	{
		return _size;
	}
	
	~My_Queue()
	{
		_size=0;
	}
private:
	stack<int> _s1;
	stack<int> _s2;
	int _size;
};

两个队列实现一个栈很类似

class My_Stack
{
public:
	My_Stack()
	{
		_size=0;
	}
	bool empty()
	{
		if(_size==0)
			return true;
		else
			return false;
	}
	void push(int data)
	{
		/*if(_q1.empty())
		{
			_q2.push(data);
		}
		else 
		{
			_q1.push(data);
		}
		_size++;*/

		_q1.push(data);
		_size++;
	}
	void pop()
	{
		if(_q1.empty()&&_q2.empty())
			return;
		//注释的这也是一种方法if(_q1.empty())
		//{
		//	int tmp=0;
		//	while(_q2.size()!=1)
		//	{
		//		tmp=_q2.front();
		//		_q1.push(tmp);
		//		_q2.pop();
		//	}
		//	_q2.pop();
		//}
		//else//_q2为空
		//{
		//	int tmp=0;
		//	while(_q1.size()!=1)
		//	{
		//		tmp=_q1.front();
		//		_q2.push(tmp);
		//		_q1.pop();
		//	}
		//	_q1.pop();
		//}
		//_size--;
		if(_q1.empty())//_q1为空且_q2不为空
		{
			int tmp=0;
			while(_q2.size()!=1)
			{
				tmp=_q2.front();
				_q1.push(tmp);
				_q2.pop();
			}
			_q2.pop();
		}
		
		else//_q1不为空，进行的处理和上面刚好相反
		{
			int tmp=0;
			while(_q1.size()!=1)
			{
				tmp=_q1.front();
				_q2.push(tmp);
				_q1.pop();
			}
			_q1.pop();
		}
		_size--;
	}
	int front()
	{
		assert((!_q1.empty())||(!_q2.empty()));
		if(_q1.empty())
		{
			int tmp=0;
			while(_q2.size()!=1)
			{
				tmp=_q2.front();
				_q1.push(tmp);
				_q2.pop();
			}
			_q1.push(_q2.front());
			tmp=_q2.front();
			_q2.pop();
			return tmp;
		}
		else//_q2为空
		{
			int tmp=0;
			while(_q1.size()!=1)
			{
				tmp=_q1.front();
				_q2.push(tmp);
				_q1.pop();
			}
			_q2.push(_q1.front());
			tmp= _q1.front();
			_q1.pop();
			return tmp;
		}
			
	}		
	int size()
	{
		return _size;
	}
	~My_Stack()
	{}
private:
	queue<int> _q1;
	queue<int> _q2;

	int _size;
};