用两个栈(Stack)实现一个队列(Queue)

用C++描述,题目大致是这样的:
 
已知下面Stack类及其3个方法Push、Pop和 Count,请用2个Stack实现Queue类的入队(Enqueue)出队(Dequeue)方法。
 
class Stack
{
…
public:
         void Push(int x); // Push an element in stack;
         int Pop();  // Pop an element out of stack;
         int Count() const;     // Return the number of the elements in stack;
…
};
 
class Queue
{
…
public:
         void Enqueue(int x);
         int Dequeue();
 
private:
         Stack s1;
         Stack s2;
…
};

大多数人的思路是:始终维护s1作为存储空间,以s2作为临时缓冲区。

入队时,将元素压入s1。

出队时,将s1的元素逐个“倒入”(弹出并压入)s2,将s2的顶元素弹出作为出队元素,之后再将s2剩下的元素逐个“倒回”s1。

见下面示意图:

上述思路,可行性毋庸置疑。但有一个细节是可以优化一下的。即:在出队时,将s1的元素逐个“倒入”s2时,原在s1栈底的元素,不用“倒入”s2(即只“倒”s1.Count()-1个),可直接弹出作为出队元素返回。这样可以减少一次压栈的操作。约有一半人,经提示后能意识到此问题。

上述思路,有些变种,如:

入队时,先判断s1是否为空,如不为空,说明所有元素都在s1,此时将入队元素直接压入s1;如为空,要将s2的元素逐个“倒回”s1,再压入入队元素。

出队时,先判断s2是否为空,如不为空,直接弹出s2的顶元素并出队;如为空,将s1的元素逐个“倒入”s2,把最后一个元素弹出并出队。

有些人能同时想到大众方法和变种,应该说头脑还是比较灵光的。

相对于第一种方法,变种的s2好像比较“懒”,每次出队后,并不将元素“倒回”s1,如果赶上下次还是出队操作,效率会高一些,但下次如果是入队操作,效率不如第一种方法。我有时会让面试者分析比较不同方法的性能。我感觉(没做深入研究),入队、出队操作随机分布时,上述两种方法总体上时间复杂度和空间复杂度应该相差无几(无非多个少个判断)。

真正性能较高的,其实是另一个变种。即:

入队时,将元素压入s1。

出队时,判断s2是否为空,如不为空,则直接弹出顶元素;如为空,则将s1的元素逐个“倒入”s2,把最后一个元素弹出并出队。

这个思路,避免了反复“倒”栈,仅在需要时才“倒”一次。但在实际面试中很少有人说出,可能是时间较少的缘故吧。

时间: 2024-08-24 13:26:25

用两个栈(Stack)实现一个队列(Queue)的相关文章

用两个栈来实现一个队列,完成队列的Push和Pop操作。 队列中的元素为int类型

import java.util.Stack; /**  * 用两个栈来实现一个队列,完成队列的Push和Pop操作. 队列中的元素为int类型.  * @author user  *  *思路:队列是先入先出,栈是先入后出,可以将数据压入第一个栈后,在弹出来压入第二个栈,弹得时候直接从第二个栈弹出,弹出后又将  *第二个栈中的所有数据弹出重新压入的一个栈  */ public class Solution {     Stack<Integer> stack1 = new Stack<

9.3栈和队列(七)——用两个栈来实现一个队列

/** * 功能:用两个栈来实现一个队列. */ import java.util.*; /** * 思路:需要修改peek()和pop(),以相反顺序执行操作.可以利用第二个栈来反转元素的次序. * stackNewest顶端为最新元素,stackOldest顶端为最旧元素,利用两个栈的元素的转移来实现. * */ public class MyQuene1 { Stack stackNewest ,stackOldest ; public MyQuene1(){ stackNewest= n

面试题9-用两个栈来实现一个队列,完成队列的Push和Pop操作

题目 用两个栈来实现一个队列,完成队列的Push和Pop操作. 队列中的元素为int类型. 思路: 一个栈压入元素,而另一个栈作为缓冲,将栈1的元素出栈后压入栈2中 代码 import java.util.Stack; /** *两个栈实现一个队列 * @author MSI */ public class Requeue{ Stack<Integer> sk1=new Stack<Integer>(); Stack<Integer> sk2=new Stack<

N5-用两个栈来实现一个队列

题目描述 用两个栈来实现一个队列,完成队列的Push和Pop操作. 队列中的元素为int类型. import java.util.Stack; /** * 用两个栈来实现一个队列,完成队列的Push和Pop操作. 队列中的元素为int类型. * @author Sonya * *进队列时,直接进入栈一中,出栈时先将栈一中的所有按照出栈次序依序压入栈2中,弹出栈2首个元素 *即为第一个入队列的元素,然后再将2所有的元素依次压入栈一中 */ public class N5_Two_stack_to_

用两个栈模拟实现一个队列

题目:如何用两个栈模拟实现一个队列?  如果这两个堆栈的容量分别是m和n(m>n),你的方法能保证的队列容量是多少?(这里讨论的是顺序栈,如果是链式栈的话完全没有必要考虑空间) 分析:栈的特点是“后进先出(LIFO)”,而队列的特点是“先进先出(FIFO)”.用两个栈模拟实现一个队列的基本思路是:用一个栈作为存储空间,另一个栈作为输出缓冲区,把元素按顺序压入两栈(模拟的队列),并按此顺序出队并输出即可. 如下图,用容量为m的栈作为存储空间,容量为n的栈作为输出缓冲区,一开始先将n个元素压入(pu

用两个栈来实现一个队列

1. class Solution { public: void push(int node) { stack1.push(node); } int pop() {//删除队列前面元素 int result; if(stack2.empty())//栈可以这样看空不 size不好 { while(!stack1.empty()) { int cc= stack1.top(); stack2.push(cc); stack1.pop(); } } result = stack2.top(); st

一张图展示:用两个栈来实现一个队列,完成队列的Push和Pop操作

一  基本思路 将s1作为存储空间,以s2作为临时缓冲区. 入队时,将元素压入s1. 出队时,将s1的元素逐个"倒入"(弹出并压入)s2,将s2的顶元素弹出作为出队元素,之后再将s2剩下的元素逐个"倒回"s1. 二 图示 三 代码实现(Java) import java.util.Stack; public class Solution { Stack<Integer> stack1 = new Stack<Integer>(); Stack

【算法】用两个栈来实现一个队列,完成队列的Push和Pop操作。 队列中的元素为int类型。

public class Solution { Stack<Integer> stack1 = new Stack<Integer>(); Stack<Integer> stack2 = new Stack<Integer>(); public void push(int node) { stack1.push(node); } public int pop() { if(stack1.empty()&&stack2.empty()){ th

C++实现单链表和子类栈(Stack)及单向队列(Queue)

刚刚开始学习c++.之前c的内容掌握的也不多,基本只是一本概论课的程度,以前使用c的struct写过的链表.用python写过简单的数据结构,就试着把两者用c++写出来,也是对c++的class,以及继承中的public/protected/private的性质进行初步了解.第一次写头文件.h和源文件.cpp分开的c++代码.过程中参考了ProLyn和kgvito的代码,基本就是百度"单链表 c++"的前几个搜索结果. 节点listNode还是用struct来写了,因为我想节点除了构造

用两个stack设计一个队列

思路:用两个栈,一个用于接收(in),一个用于输出(out),输出前如果out为空需要将in中的数据导入out. import java.util.Stack; //用两个stack设计一个队列 p142 public class MyQueue<T> { Stack<T> in; Stack<T> out; public MyQueue() { in = new Stack<T>(); out = new Stack<T>(); } publi