目录
前言
一、读懂题目
二、思路分析
三、代码呈现
总结
前言
当我们需要实现队列的先进先出特性时，可以使用栈来模拟队列的行为。本文将介绍如何使用两个栈来实现队列，并给出具体的思路和代码实现。
一、读懂题目
题目：用两个栈实现一个队列。队列的声明如下，请实现它的两个函数 appendTail 和 deleteHead，分别完成在队列尾部插入结点和在队列头部删除结点的功能。
当我们需要利用栈来实现队列先进先出的特性时，考虑到单个栈对存入的一组数据push后再逐位pop取出，对应的序列和输入的顺序相反，那我们是否可以用两个栈，抽象类似于负负得正的手法，使得top位逐个取出得到的序列和插入时是相同的？
二、思路分析
首先基础类定义如下，我们只需要补充里面 appendTail 和 deleteHead 两函数的定义即可：
// 用两个栈实现队列
template<typename T>
class MyQueue
{
public:
void appendTail(const T& n);
T deleteHead();
private:
stack<T> st1;
stack<T> st2;
};为了便于表示和说明，设定一组数据 {a, b, c, d, e} 作为测试序列。
我们看到两个栈都可存储数据，那我们不妨先将数据全部存入st1中，那么根据栈先进后出的特性，两栈中数据的存储此时应该是这样的：
既然我们想到试试“负负得正”这种方法，那要是把st1中的元素再一 一取出放入st2中，是不是相当于把序列的顺序调转再调转，这样当我们不断取 st2.top() 时，最后按照取出的序列就是原来顺序的初始序列！
我们模拟一下这个过程：
1）对st1执行两次取首压入st2中：
2）将剩余元素从st1中全部压入st2中，此时st1为空：
3）最后每当该模拟队列执行一次 front() 操作就返回 top2 所指向的值，每次 pop() 就从 st2 取出栈顶元素（前提是st1为空），直到 st2 栈为空：
那如果在执行 front() 过程中，夹杂着新的push()指令，应该将新元素放入st1还是st2呢？如果st1不为空，要先将st1全部按照上面的规则移入st2后再插入还是先放入st1栈顶，再统一移入st2呢？
首先我们明确每个元素都需要经历“负负得正”的过程，所以首先新加元素肯定要先经过st1才能进入st2中。那是否需要st1及时清空呢？
我们不妨以 {a, b, c, d}, {e} 模拟两批次对模拟队列执行push()指令：
假定我们在每批操作结束就将该批的元素依次弹出并置入st2中，那么当需要输入上面第二组（即{e}）时，st1和st2的存储情况如下：
接下来该插入第二批数据了，但是实际功能调用过程中，不可能每次单批次插入操作之间是连续的，中间可能会有删除队列中已有元素的操作，所以我们不妨在两次 push() 指令中间加一句 pop_front() 指令，那么当接着执行一次pop_front() 指令时，对于st2而言应该将 a 元素剔除。同时我们注意到 a 元素正如我们所料位于st2的栈顶，当 st2.pop() 操作执行时，取出 a 元素，符合队列先进先出的特性。此时st1为空，st2顶部元素为b，如下图：
下一步我们进行第二批插入，将元素 e 执行 push() 操作时，显然 e 需要先进st1中，所以st1中此时不为空，元素ｅ即为st1栈顶元素：
那么此时我们要不要把st1中的所有元素（这里仅有 e ）顺手植入st2中呢？
1）如果移入st2中：
现在面临一个问题：如果我们一次性取出st2中的元素，亦或是仅取st2栈顶元素执行 st2.pop() 来获得理想的队列头，却发现得到的结果并不满足我们的设计需求，两轮输入的总序列为 {a, b, c, d, e} ，而取出序列为 {a, e, ... }，显然不符合先进先出的原则。
那是否意味着第二批的输入元素应该先保存在st1中，并非单批输入结束后就将其接着压入st2中，那为什么首批输入的数据就可以直接经st1后全部置入st2呢？
难道因为开始时候 st2 为空吗？那如果后续其他批次插入时，也遵循 st2 为空后再将 st1 中所有元素置于 st2 中，会不会发生这样的冲突？
不妨我们按照这样的设计思路进行测试：
首先给出部分功能的此思路代码：
1）清空 st1 容器功能代码
template<typename T>
void MyQueue<T>::appendOver()
{
if (st2.empty()) // 只有满足st2为空才清空st1
{
while (!st1.empty())
{
st2.push(st1.top());
st1.pop();
}
}
}2）模拟 front() , push() 和 pop() 的函数功能
template<typename T>
T& MyQueue<T>::front()
{
if (!st1.empty())
{
appendOver();
}
assert(!st2.empty());
return st2.top();
}
template<typename T>
void MyQueue<T>::appendTail(const T& n)
{
st1.push(n);
}
template<typename T>
T MyQueue<T>::deleteHead()
{
assert(!empty()); // 不能同时为空
if (st2.empty())
{
appendOver();
}
T tmp_poped = st2.top();
st2.pop();
return tmp_poped;
}3）实际测试代码
void test1()
{
MyQueue<int> mq;
// queue.push()模拟尾插
for (int i = 10; i > 0; i--)
{
mq.appendTail(i);
} // 1 2 3 4 5 6 7 8 9 10 右侧栈顶
// queue.front()模拟取首元素
// appendTail()--push()模拟入队列操作
// deleteHead()--pop()模拟删除队列首元素
mq.deleteHead(); // st1中：空 st2中：1 2 3 4 5 6 7 8 9 右侧栈顶
mq.appendTail(100); // st1中：100 st2中：1 2 3 4 5 6 7 8 9 右侧栈顶
// 由于st2不为空，st1中元素不发生迁移
// 经过上面两步 st1中：100 st2中：1 2 3 4 5 6 7 8 9
// 假设我们再进行一组类似操作
mq.deleteHead(); // st1中：100 st2中：1 2 3 4 5 6 7 8 右侧栈顶
mq.appendTail(55); // st1中：55 100 st2中：1 2 3 4 5 6 7 8 右侧栈顶
int val = mq.deleteHead(); // st1中：55 100 st2中：1 2 3 4 5 6 7 右侧栈顶
printf("val = %d\n", val); // 8
PopAndPrintMyQueue<int>(mq);
}按理来说结果应该和各行代码后面的理想推测相同，我们看看最后两行执行结果：
可以看到和我们推测的结果完全一致，我们不仅在上面完成了一组插入删除后，额外执行了一组插入和删除操作，最后打印整个模拟队列中剩余元素时，呈现的结果和传入的顺序也相同，同样可以采用其他各种操作，统计每次取出的元素组成的序列是否满足先进先出的特性，结果终究是符合的。
三、代码呈现
下面直接给出代码：
// 用两个栈实现队列
template<typename T>
class MyQueue
{
public:
void appendTail(const T& n);
T deleteHead();
T& front();
bool empty();
private:
void appendOver(); // 将st1中元素的全部移入st2中 --- 前提：st2不为空
stack<T> st1;
stack<T> st2;
};
template<typename T>
void MyQueue<T>::appendTail(const T& n)
{
st1.push(n);
}
template<typename T>
void MyQueue<T>::appendOver()
{
if (st2.empty()) // 只有满足st2为空才清空st1
{
while (!st1.empty())
{
st2.push(st1.top());
st1.pop();
}
}
}
template<typename T>
bool MyQueue<T>::empty()
{
if (st1.empty() && st2.empty())
{
return true;
}
return false;
}
template<typename T>
T MyQueue<T>::deleteHead()
{
assert(!empty()); // 不能同时为空
if (st2.empty())
{
appendOver();
}
T tmp_poped = st2.top();
st2.pop();
return tmp_poped;
}
template<typename T>
T& MyQueue<T>::front()
{
if (st2.empty())
{
appendOver();
}
assert(!st2.empty());
return st2.top();
}
template<typename T>
void PopAndPrintMyQueue(MyQueue<T>& my_q)
{
while (!(my_q.empty()))
{
cout << my_q.front() << "\t";
my_q.deleteHead();
}
cout << endl;
}
void test1()
{
MyQueue<int> mq;
// queue.push()模拟尾插
for (int i = 10; i > 0; i--)
{
mq.appendTail(i);
} // 1 2 3 4 5 6 7 8 9 10 右侧栈顶
// queue.front()模拟取首元素
// appendTail()--push()模拟入队列操作
// deleteHead()--pop()模拟删除队列首元素
mq.deleteHead(); // st1中：空 st2中：1 2 3 4 5 6 7 8 9 右侧栈顶
mq.appendTail(100); // st1中：100 st2中：1 2 3 4 5 6 7 8 9 右侧栈顶
// 由于st2不为空，st1中元素不发生迁移
// 经过上面两步 st1中：100 st2中：1 2 3 4 5 6 7 8 9
// 假设我们再进行一组类似操作
mq.deleteHead(); // st1中：100 st2中：1 2 3 4 5 6 7 8 右侧栈顶
mq.appendTail(55); // st1中：55 100 st2中：1 2 3 4 5 6 7 8 右侧栈顶
int val = mq.deleteHead(); // st1中：55 100 st2中：1 2 3 4 5 6 7 右侧栈顶
printf("val = %d\n", val); // 8
PopAndPrintMyQueue<int>(mq);
}
值得注意的是，上面对重要功能的安全性检查中，下面两种写法其本质是相同的：
// 1.
if (st2.empty())
{
appendOver();
}
assert(!st2.empty());
// 2.
assert(!empty()); // 不能同时为空
if (st2.empty())
{
appendOver();
}总结
本文详细介绍了如何利用栈来实现队列的先进先出特性。通过使用两个栈，我们可以将插入的顺序和取出的顺序保持一致。文章讨论了具体的实现思路，并通过代码实例进行了测试。通过测试结果，我们验证了模拟队列的各种操作都满足先进先出的特性。这种使用栈实现队列的方法在实际应用中具有重要的意义。
