两个队列实现一个栈

基本思路：

（1）队列不能对队尾进行删除操作，而栈要对栈底进行删除操作，这句需要将对队列进行一步一步的pop()操作，取到队尾元素，将其删除，为了保证前面的顺序还可以复原，那么就需要另一个队列，来存储元素

（2）其实不用像两个栈实现一个队列一样，push()在一个栈中，而pop()必须在另外一个栈中，因为两个栈中的元素顺序是不一样的，

而队列而言，两个队列来回到是的顺序是一样的，所以对那个进行push()和pop()操作都是一样的

代码如下：

函数声明：

template<class T>
class TwoQueueOfStack
{
public:
	TwoQueueOfStack(){};
	~TwoQueueOfStack(){};
public:
	void Push(const T& x);
	void Pop();
	T& Top();
	bool Empty()const;
	size_t Size()const;
protected:
	void Data1ToData2();
	void Data2ToData1();
private:
	queue<T> queueData1;
	queue<T> queueData2;
};

具体实现：

template<class T>
void TwoQueueOfStack<T>::Data1ToData2()
{
	while (!queueData1.empty())
	{
		queueData2.push(queueData1.front());
		queueData1.pop();
	}
}

template<class T>
void TwoQueueOfStack<T>::Data2ToData1()
{
	while (!queueData2.empty())
	{
		queueData1.push(queueData2.front());
		queueData2.pop();
	}
}



template<class T>
void  TwoQueueOfStack<T>::Push(const T& x)
{
	if (!queueData1.empty())
	{
		queueData1.push(x);
	}
	queueData2.push(x);
}


template<class T>
void  TwoQueueOfStack<T>::Pop()
{
	if (!queueData1.empty())
	{
		while (queueData1.size() != 1)
		{
			queueData2.push(queueData1.front());
			queueData1.pop();
		}
		queueData1.pop();
	}
	else 
	{
		assert(!queueData2.empty());
		while (queueData2.size()!=1)
		{
			queueData1.push(queueData2.front());
			queueData2.pop();
		}
		queueData2.pop();
	}
}

template<class T>
T& TwoQueueOfStack<T>::Top()
{
	if (!queueData1.empty())
	{
		return queueData1.back();
	}
	else
	{
		assert(!queueData2.empty());
		return queueData2.back();
	}
}



template<class T>
bool TwoQueueOfStack<T>::Empty()const
{
	return queueData1.empty() || queueData2.empty();
}

template<class T>
size_t TwoQueueOfStack<T>::Size()const
{
	return queueData1.size() + queueData2.size();
}