解题笔记（12）——用两个栈实现队列

         问题描述：用两个栈来实现队列，有如下声明：

template<typename T>
class SQueue
{
public:
	SQueue() {}
	~SQueue() {}
	void PushBack(const T &x);
	void PopFront();
private:
	stack<T> m_stack1;
	stack<T> m_stack2;
};

         思路：栈是先进后出，而队列是先进先出。可以这样设计，一个栈用于入队列操作，设为Stack1，另一个栈用于出队列操作，设为Stack2。入队列可以在常数时间内完成，即Stack1的入栈操作。而出队列时，若Stack2的元素不为空，Stack2执行出栈操作，相当于出队列。若为空，则将Stack1的元素一个个出栈，压入Stack2中，然后Stack2再执行一次出栈操作。举个简单的例子。入队列的顺序为1、2、3、4、5，出队列的顺序为1、2、3、4、5。

                          操作                                Stack1自栈顶到栈底的元素                Stack2自栈顶到栈底的元素                 出队列的元素

  PushBack(1)  PushBack(2)    PushBack(3)            3      2       1                                                    空

                    PopFront()                                                        空                                                         2           3                                     1

  PushBack(4)     PushBack(5)                                      5        4                                                    2           3

                    PopFront()                                                   5        4                                                            3                                            2

                    PopFront()                                                   5        4                                                           空                                           3

                    PopFront()                                                         空                                                               5                                            4

                    PopFront()                                                         空                                                               空                                          5

         参考代码：

template<typename T>
class SQueue
{
public:
	SQueue() {}
	~SQueue() {}
	void PushBack(const T &x);
	void PopFront();
private:
	stack<T> m_stack1;
	stack<T> m_stack2;
};

template<typename T> 
void SQueue<T>::PushBack(const T &x)
{
	m_stack1.push(x);
}

template<typename T> 
void SQueue<T>::PopFront()
{
	if(m_stack2.size() == 0) 
	{
		while(m_stack1.size() > 0)
		{
			m_stack2.push(m_stack1.top());
			m_stack1.pop();
		}
	}
	if(m_stack2.size() > 0)
		m_stack2.pop();
}

        上面是用两个栈实现队列，其实也可以用两个队列实现栈。有如下声明：

template <typename T>
class QStack
{
public:
	QStack() {}
	~QStack() {}
	void PushBack(const T &x);
	void PopBack();
private:
	queue<T> m_queue1;
	queue<T> m_queue2;
};

         思路：稍微复杂了一点，容易想到的就是这种设计。出栈时，检查两个队列，找到元素个数不为空的那个队列，执行出队列操作。如果是压栈操作，找到元素为空队列Queue1，执行入队列操作，然后Queue2执行出队列操作，出来的元素依次进入Queue1。举个简单的例子。入栈的顺序为1、2、3、4，中间有一次出栈操作，出栈顺序为3、4、2、1.。

                          操作                                Queue1自队首到队尾的元素               Queue2自队首到队尾的元素                 出栈的元素

                     PushBack(1)                                               1

                     PushBack(2)                                             空                                                          2         1

                     PushBack(3)                                          3    2    1                                                      空                   

                      PopBack()                                               2     1                                                                                                           3                      

                     PushBack(4)                                             空                                                         4     2      1                                  

                     PopBack()                                                空                                                               2      1                                       4

                     PopBack()                                                空                                                                 1                                             2

                     PopBack()                                                空                                                                  空                                          1                         

            参考代码：

template <typename T>
class QStack
{
public:
	QStack() {}
	~QStack() {}
	void PushBack(const T &x);
	void PopBack();
private:
	queue<T> m_queue1;
	queue<T> m_queue2;
};

template <typename T>
void QStack<T>::PushBack(const T &x)
{
	if(m_queue1.size() == 0)
	{
		m_queue1.push(x);
		while(m_queue2.size() > 0)
		{
			m_queue1.push(m_queue2.front());
			m_queue2.pop();
		}
	}
	else
	{
		m_queue2.push(x);
		while(m_queue1.size() > 0)
		{
			m_queue2.push(m_queue1.front());
			m_queue1.pop();
		}
	}
}
template <typename T>
void QStack<T>::PopBack()
{
	if(m_queue1.size() > 0)
		m_queue1.pop();
	else if(m_queue2.size() > 0)
		m_queue2.pop();
}

          本人享有博客文章的版权，转载请标明出处 http://blog.csdn.net/wuzhekai1985