两个栈实现一个队列

参考文章——两个栈实现一个队列

一、基础

队列属于先进先出类型，即插入数据在队尾进行，删除数据在队头进行。在c++中只要#include<queue>即可使用队列类。
其中在面试或笔试中常用的成员函数如下：

1. push
2. pop
3. size
4. empty
5. front
6. back

栈属于先进后出，即插入与删除数据均在栈顶进行。

二、两个栈实现队列

两个栈，一个可以作为队列的入口，负责插入新元素；另一个栈作为队列的进口，负责移除老的元素。

入队：将新元素压入栈A中 A（1，2，3）
出队：若想要最先入队的元素出队
让栈A的所有元素按顺序出栈，再按照出栈顺序压入栈B。B（3，2，1）此时让队头的元素出队，就是让元素1从栈B弹出。
再次入队：若此时又做入队操作呢？当有新元素入队时，重新把新元素压入栈A。
再次出队：此时的出队操作仍然从栈B弹出元素。若栈B已经空了，还想出栈怎么办？只要栈A还有元素，就像刚才的操作，把栈A元素弹出并压入栈B。再从栈B中弹出。

功能实现的思路

（1）使用两个栈A，B，其中假定A负责push操作，B负责pop操作。使用一个变量back_elem来存储最后添加的元素。
（2）实现队列的push操作，每次进行添加操作，都会相应得对栈A进行添加元素，并对back_elem赋值。
（3）实现队列的pop操作，每次进行删除操作，因为栈B负责pop操作。
首先判断栈B是否为空？
a.如果B为空，则判断A是否为空？
如果A也为空，则输出错误信息，此时队列为空。
如果A不为空，则将栈A中的所有数据存储到B中。执行B.push(A.top), A.pop(). 然后对栈B执行B.pop()操作，将队列的头元素删除。
b.如果B不为空，则直接对B执行B.pop()操作。
（4）实现队列的front()操作，方法如pop操作相同，只是在最后一步使用B.top()返回值。
（5）实现队列的back()操作，因为变量back_elem保存着最后一个输入的数据，故直接将其返回。
（6）实现队列的size()和empty()，就是对栈A，B分别执行操作。

c++代码实现

#include <iostream>
#include <stack>
#include <string>
using namespace std;
 
template<typename T>
class Queue {
private:
	stack<T>stackA;	//栈A
	stack<T>stackB;	//栈B
	T back_elem;	//用于存储新添加的元素
public:
	void push(T elem);	//将新元素压入队列（压入栈A）中
	void pop();			//将元素弹出队列（从栈B中弹出）
	T front();			//队首元素
	T back();			//队尾元素
	int size()const;    //队列长度
	bool empty()const;  //队列是否为空
};
 
/*
入队操作
实现队列的push操作， 每次进行添加操作，都会相应得对栈A进行添加元素。并对back_elem赋值
*/
template<typename T>
void Queue<T>::push(T elem)
{
	stackA.push(elem);//将元素压入队列
	back_elem = elem;	//存储新添加的元素
}
 
/*
出队操作
实现队列的pop操作，每次进行删除操作，因为栈B负责pop操作。
首先判断栈B是否为空？
a.如果栈B为空，则判断A是否为空？
		如果A也为空，则输出错误信息，此时队列为空。
		如果A不为空，则将栈A中的所有数据存储到B中。执B.push(A.top()), A.pop().然后在对栈B
			执行，B.pop()操作，将队列的头元素删除
b.如果栈B不为空， 则直接对栈B执行 B.pop()操作。
*/
template<typename T>
void Queue<T>::pop()
{
	//判断栈B是否为空？
	if (!stackB.empty())	//栈B不为空， 则直接对栈B执行 B.pop()操作。
	{
		stackB.pop();
	}
	else if (!stackA.empty())	//栈B为空，则判断栈A是否为空？栈A不为空,则将栈A中的所有数据
   //存储到B中。执B.push(A.top()), A.pop().然后在对栈B执行，B.pop()操作，将队列的头元素删除
	{
		stackB.push(stackA.top());
		stackA.pop();
	}
	else
	{
		std::cout << "error pop(),empty queue!" << std::endl;
	}
}
 
/*
队首元素
*/
template<typename T>
T Queue<T>::front()
{
	if (!stackB.empty())
	{
		return stackB.top();
	}
	else if (!stackA.empty())
	{
		while (!stackA.empty())
		{
			stackB.push(stackA.top());
			stackA.pop();
		}
		return stackB.top();
	}
	else
	{
		std::cout << "error front(),empty queue!" << std::endl;
	}
}
 
/*
队尾元素
*/
template<typename T>
T Queue<T>::back()
{
	if (!empty())
	{
		return back_elem;
	}
	else
	{
		std::cout << "error back(),empty queue!" << std::endl;
	}
}
 
/*
队列长度
*/
template<typename T>
int Queue<T>::size() const
{
	return stackA.size() + stackB.size();
}
 
/*
队列是否为空
*/
template<typename T>
bool Queue<T>::empty() const {
	return stackA.empty() && stackB.empty();
}
 
int main()
{
	Queue<int>queue;
	//入队操作
	queue.push(1);
	queue.push(2);
	queue.push(3);
	queue.push(4);
	cout << "Four times push() After:" << endl;
	//队首元素
	cout << "The queue front:" << queue.front() << endl;
	//队尾元素
	cout << "The queue back:" << queue.back() << endl;
	//队列size
	cout << "The queue size:" << queue.size() << endl;
	//出队操作
	queue.pop();
	queue.pop();
	queue.pop();
	queue.pop();
	cout << "----------------------------" << endl;
	cout << "Four times pop() After:" << endl;
	//队首元素
	cout << "The queue front:" << queue.front() << endl;
	//队尾元素
	cout << "The queue back:" << queue.back() << endl;
	//队列size
	cout << "The queue size:" << queue.size() << endl;
 
	//system("pause");
	return 0;
}

时间复杂度

入队时间复杂度是O(1)。出队操作，如果涉及到栈A 和栈B的元素迁移，时间复杂度为O(n),如果不用元素迁移，时间复杂度是O(1)