使用两个队列实现堆栈的意义何在？

我有以下作业问题：

使用两个队列实现堆栈方法push（x）和pop（）。

我觉得这很奇怪，因为：

• 堆栈是（LIFO）队列
• 我不明白为什么您需要两个队列来实现它

我到处搜寻：

• 极客
• 堆栈溢出

并找到了一些解决方案。我最终得到的是：

public class Stack<T> {
    LinkedList<T> q1 = new LinkedList<T>();
    LinkedList<T> q2 = new LinkedList<T>();

    public void push(T t) {
        q1.addFirst(t);
    }

    public T pop() {
        if (q1.isEmpty()) {
            throw new RuntimeException(
                "Can't pop from an empty stack!");
        }

        while(q1.size() > 1) {
            q2.addFirst( q1.removeLast() );
        }

        T popped = q1.pop();

        LinkedList<T> tempQ = q1;
        q1 = q2;
        q2 = tempQ;

        return popped;
    }
}

但是我不了解使用单个队列的好处是什么；两个队列版本似乎毫无意义地复杂。

假设我们选择2的效率更高（如我上面所做的那样），push将保持不变，并且pop只需要迭代到最后一个元素并返回它。在两种情况下，“ push将是O(1)”和“ pop将是” O(n)；但单队列版本将大大简化。它只需要一个for循环。

我想念什么吗？这里的任何见解将不胜感激。

没有优势：这纯粹是学术活动。

一个很长的时间以前，当我还是一个新生在大学我也有类似的锻炼¹。目的是教学生如何使用面向对象的编程来实现算法，而不是使用for带有循环计数器的循环编写迭代解决方案。相反，组合并重用现有数据结构可以实现您的目标。

您将永远不会在Real World ^TM中使用此代码。您需要从此练习中脱颖而出的是如何“跳出框框思考”和重用代码。

请注意，您应该可以使用java.util.Queue中的代码中的接口，而不是直接使用实现：

Queue<T> q1 = new LinkedList<T>();
Queue<T> q2 = new LinkedList<T>();

Queue如果需要的话，这允许您使用其他实现，以及隐藏²种LinkedList可能绕开Queue界面精神的方法。这包括get(int)和pop()（在编译代码时，在给定分配约束的情况下，那里存在逻辑错误。将变量声明为Queue而不是LinkedList会显示出来）。相关阅读：了解“对接口编程”，以及为什么接口有用？

^{1 _{我仍然记得：这样做的目的是仅使用Stack接口上的方法来反转Stack，而在java.util.Collections其他“仅静态”实用程序类中不使用任何实用程序方法。正确的解决方案包括使用其他数据结构作为临时保存对象：您必须了解不同的数据结构，它们的属性以及如何将它们组合在一起以实现此目的。困扰我以前从未编程的CS101类的大多数人。}}

^{2 _{这些方法仍然存在，但是如果没有类型强制转换或反射，就无法访​​问它们。因此，使用这些非排队方法并不容易。}}

没有优势。您已经正确认识到，使用队列实现堆栈会导致可怕的时间复杂性。没有（称职）程序员会在“现实生活”中做这样的事情。

但这是可能的。您可以使用一种抽象来实现另一种抽象，反之亦然。一个堆栈可以用两个队列来实现，同样，您可以用两个堆栈来实现一个队列。此练习的优点是：

• 您回顾一下堆栈
• 您回顾队列
• 您习惯了算法思维
• 您学习与堆栈有关的算法
• 您开始考虑算法的权衡
• 通过了解队列和堆栈的等效性，可以连接课程的各个主题
• 您将获得实际的编程经验

实际上，这是一个很棒的练习。我现在应该自己做：）

从两个堆栈中取出一个队列绝对是一个真正的目的。如果使用功能语言中的不可变数据结构，则可以推入可推项目的堆栈，并从可弹出项目的列表中拉出。当弹出所有项目时，将创建poppable项，并且新的poppable堆栈与pushable堆栈相反，此时pushable堆栈为空。效率很高。

至于由两个队列组成的堆栈？在您有大量可用的大型和快速队列的情况下，这可能很有意义。这种Java练习绝对没有用。但是，如果这些是通道或消息队列，则可能有意义。（即：N条消息入队，并执行O（1）操作将前面的（N-1）个项目移到新队列中。）

从实际的角度来看，该练习是不必要的。关键是要迫使您以一种聪明的方式使用队列的接口来实现堆栈。例如，您的“一个队列”解决方案要求您遍历队列以获取堆栈“ pop”操作的最后一个输入值。但是，队列数据结构不允许迭代这些值，因此只能以先进先出（FIFO）的方式访问它们。

正如其他人已经指出的那样：没有现实优势。

无论如何，对于问题第二部分的一个答案（为什么不简单地使用一个队列）超出了Java。

在Java中，即使Queue接口也有一个size()方法，并且该方法的所有标准实现都是O（1）。

对于C / C ++程序员将要实现的幼稚/规范链表，这不一定是正确的，它只会保留指向第一个和最后一个元素的指针，而每个元素保留指向下一个元素的指针。

在这种情况下size()为O（n），应避免循环。或实现是不透明的，仅提供最低的add()和remove()。

通过这样的实现，您必须先将元素转移到第二个队列中，再将n-1元素转移回第一个队列中，然后返回剩余的元素，以计算元素的数量。

就是说，如果您生活在Java领域，它可能不会构成这样的东西。

很难想象这种实现的用途，这是事实。但是最重要的是证明它是可以做到的。

但是，就这些东西的实际用途而言，我可以想到两个。一种用途是在并非为它设计的受限环境中实现系统：例如，Minecraft的红石块最终代表了图灵完备的系统，人们已经习惯了该系统来实现逻辑电路甚至整个CPU。在脚本驱动游戏的早期，许多第一个游戏机器人也都是通过这种方式实现的。

但是，你也可以在反向运用这一原则，确保东西是不是能够在一个系统中，当你不希望它是。这可能出现在安全性上下文中：例如，功能强大的配置系统可能是资产，但是您仍然宁可不给予用户一定程度的权力。这限制了您可以允许配置语言执行的操作，以免遭到攻击者的破坏，但是在这种情况下，这就是您想要的。