用有限个栈模拟常数效率操作的队列

Posted dacc123

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了用有限个栈模拟常数效率操作的队列相关的知识,希望对你有一定的参考价值。

问题来源

写这篇博客来源于一次面试的经历。不过并不是我被面试,而是我面试别人。如何用两个栈实现一个队列?这算是一个经典的面试题。因为它经常被拿来用。如果对栈和队列比较掌握的人,就可以轻松的答出来。

然而,那天坐在对面的面试者直接抛出:如何用有限个栈模拟常数效率操作的队列呢?作为一个面试官,我佯装镇定,因为这个和用栈实现队列可是一个天上一个地下的区别。听他说完。之后几个小时的面试,我根本无心面试,脑子里一直在想:他刚才说了啥?到底是怎么操作的?太优秀了!

看完这篇文章,以后面试别人或者被面试的过程中,遇到如何用栈实现一个队列的问题,那么就可以秀一波操作了。应该很少能有人在临场反应中能够答出来吧。
当然篇幅有点长,也有点绕脑子。就当做是繁忙工作之余的一个点心。接下来就开始品尝吧。

老生常谈

如何用两个栈实现一个队列呢?这是一个老生常谈的问题,为了扩充博文的长度我决定还是写一下过程。

比较笨的方法我就不说了( 一个栈作为缓冲栈,另一个储存数据,当出队列的时候,元素从一个栈倒出来,再倒回去。可真麻烦)

我们用两个栈分别代表一个队列的 尾部 tail 和一个队列的头部 head 。根据队列的特性,尾部栈只负责入队列操作,头部栈只负责出队列操作。

技术图片

过程就如上图所示,当要出队列的时候,如果头部栈有元素,那么立刻出栈,效率O ( 1 )。

如果头部栈元素空了,就会把尾部栈的元素全部倒入头部栈中,再出栈。很显然倒元素的过程是一个O ( n )效率的操作,n是尾部栈里的元素个数。

出队列的效率就是O(n+1) (出队列操作也算上)而进栈都是O( 1 )的操作。

两个栈实现一个队列的效率

那么这样一个队列,它的效率高不高呢?

如果这样对队列进行操作:进队列 - 出队列 - 进队列 - 出队列 -进队列 ....

每次出队列效率是O (2) ,那n次出队列的效率就是 O ( 2 )+ O ( 2 ) + O( 2 )... => O( 2*n )

如果我这样操作:进队列 - 进队列 - 进队列 .... 出队列 出队列 出队列 ....

那么出n次队列的效率 是O( n+1 ) +O(1 )+O( 1 )+ ... => O( 2*n )

两种极端的情况下n次出队列的效率总的是 O (2*n) (别的情况下也是如此) 所以平均每次出队列的效率是O ( 2 ) !是常数效率!

这不就已经达到文章标题的要求了吗??对,是的,是我的题目不严谨。这道题目是源自于算法第四版的习题:

用有限个栈实现一个队列,保证每个队列(在最坏的情况下)都只需要常数次的栈操作

上面的方法在 最坏的情况下 是不满足的,也就是O(n+1)的那一次。

题外话

C# 中的 List 是怎么做到 Add 自动增加长度的呢?不是动态分配内存,而是当 List内部的array数组快满的时候 ,卡,一下直接复制一个二倍长度的array数组替换之前的数组,之后你再慢慢Add,直到再次堆满数组。相关操作可以查看List的源码

C# 中的 List 都可以这样操作,说明偶尔一次操作不是常数,并不影响整个数据结构的效率。可以平均一下(为啥平均要加粗,因为它是接下来的主要算法思想),相当于常数效率了。

所以上述栈模拟队列的操作完全合情合理,没什么不好的地方。不好的是这道习题,非要在最坏的地方也需要常数次操作。到这里其实这道题目已经不是优化效率的题目,也不是考验你的栈和队列的熟练程度,而是脑筋急转弯题。

解决思路

就像之前所说的:

进队列 - 出队列 - 进队列 - 出队列 -进队列 ....

它完美的避开了那最坏的情况。因为它每次进队列之后都出队列,那么尾部栈里的元素就很少,这是不会出现O(n)操作的关键:确保尾部栈的元素时时刻刻都要最少,而头部栈的元素要最多

所以核心思路 就是:

将那次最坏情况下的 出队列倒元素的 O(n) 操作给平均到每次出入队列的操作中,确保尾部栈的元素时时刻刻都要比头部栈的元素少。

如果理解不了,也没关系,接下来会一步一步围绕这个思路去解决问题。

NO.1 头部栈副本

初始情况

这是一个开始的双栈模拟一个队列的情况:
技术图片

如果一直在出队列,刷刷几下把头部栈的元素出光了,那么下一次出队列就是最坏的情况了。

引入头部栈副本

要做到尾部栈时时刻刻都在往头部栈里倒元素,需要引入另一个头部栈的副本head-l ,两个头部栈属于双胞胎关系。
在出队列的同时,我们把尾部栈的元素同时倒入头部栈副本中,当头部栈的元素出光了,下次出队列时只要交换头部栈和头部栈副本,就可以完美的衔接起来,避免了最坏情况的发生。
技术图片


NO.2尾部栈副本

细心的同学应该发现了,如果在上述过程中,突然进队列怎么办呢?尾部栈突然进队列,那么就不能再往头部栈副本中倒元素了。既然有头部栈副本,那么也可以有一个尾部栈副本 :tail-l
进队列往尾部栈副本中放元素。此时进出队列的栈为 :tail-lhead
技术图片

等到头部栈放空了,尾部栈倒空了,此时转换角色。出队列在head-l,入队列在tail。 而倒元素是从tail-lhead中倒元素

到这里,应该窥见了这样操作的中心思想:疯狂的,一刻不停歇的让tail中的元素进入head中,总是保持tail中的元素少于head中的元素

四个栈完美的实现了队列中出队列操作始终在常数效率。那么问题是不是就解决了呢?很显然没有,到这里才是一半。


NO3.头部栈副本二

接下来,随着栈的数量增多,请一定要保持头脑清醒,对栈有着深刻和正确的认识。

疯狂进队列,不出出队列

如果在上述过程中,不出队列,一个元素也不出,而是疯狂进队列呢?
技术图片

上图的过程是:在tail-l中入队列,当tail中元素倒空了,便交换角色,tail属于入队列的栈。(原则一:入队列时,哪个尾部栈谁是空的,谁就作为入队列栈,这样方便我们用代码实现)

疯狂进队列的后果

与此同时一个元素也不出队列。所以最终导致的结果是tail中的元素老多了,老高了。那么会导致啥后果呢?从现在看来,出队列照样可以O(1)啊,如果聪明一点的同学应该会预料到会发生这样的情况:一直出队列的话

技术图片

上图的过程:先从head中出队列,当head中元素出完了,便交换角色,head-l 出队列。与此同时,tail-l向已经空的head中倒元素(原则二:当某个头部栈为空时,那么尾部栈副本应该向这个头部栈转移元素,这里的尾部栈副本不一定就是tail-l,也可以是tail,因为它们二者是交换角色的关系)

同理head-l元素出完了,又和head交换角色,根据原则二,tail中的元素需要向head-l中倒元素。直到head出队列出空了。

此时按道理应该head-lhead交换角色,但这个时候却发现tail栈中的元素没倒完啊,元素13 还压在箱底呢!怎么办呢?一次性倒完吧!可是这又违背了常数操作的规定啊。谁知道tail栈中剩的元素会是多少个呢?

引入头部栈副本二解决问题

为了解决这个问题,再引入一个头部栈副本二:head-r ,这个栈专门用来让head去倒元素进去,为什么要这样做呢?看图就知道了,上下两个图是衔接的关系。

技术图片

技术图片

我们选取 疯狂进队列时的情况,加入head-r, 在往tail中进队列的时候,head-lhead-r中倒元素。 当没有head-r时,由于没有出队列,所有的头部栈的元素都原封不动,但因为了有了head-r,那么head-l就会倒空,那么根据原则二, tail-l就需要往head-l中倒元素。

tail-l倒空之后,head-r的元素再倒回head-l,于是便得到最后一个张图:tailhead-l中的元素是一样多的,所以无论怎么出队列都不会出现tail栈中的元素没倒完的情况。

所以引入head-r后,又多了一个原则三:head-r为空时,需要从head栈中倒元素到head-r

所以head-r就是为了缓解头部栈元素原封不动的情况,让尾部栈元素可以流动起来


NO.4 头部栈副本三

根据原则三:上面图的最后一个应该是这样的情况
技术图片

同时出队列和转移元素,这样就很尴尬了!!怎么办呢?再来一个栈!(栈多随便用,别搞出n个栈就可以)
这个栈是头部栈副本三号!叫做head-c ,它是专门的一个临时栈,相当于 当前处于出队列 状态的头部栈的引用。 出队列的操作都从head-c中实现,而代码实现其实可以用很巧妙的方法:一个栈,两个游标,分别代表自身和head-c

所以下图中名义上是head-l在出队列,实际上是head-c在出队列

技术图片

此外还有一点,在head-c中出队列,就需要在head-r中标记出来。下次head-r需要倒元素的时候,就要注意标记的元素已经被出队列了。

代码实现

c++: 根据上文中的三个原则,以及一个栈,两个游标,再注意标记出队列元素。就可以很容易实现代码了。

c++ 有指针,指来指去,就更方便了。

#include <iostream>
#include <stdio.h>
#include <math.h>
#include <algorithm>

using namespace std;


struct StackHead
{
    int s[1005];
    int top=0;
    int top_c=0;
};

struct Stack
{
    int s[1005];
    int top=0;
    int dequeue=0;
};

class Queue
{
public:
    int num;
    StackHead* head;
    StackHead* head_l;
    Stack* tail;
    Stack* tail_l;
    Stack* head_r;
    Queue();
    void Enqueue(int number);
    int Dequeue();
  
private:
    int copy_tail;
    int copy_head;
    void Judge();
    void Copy();
    void Change();
};

Queue::Queue()
{
    head = new StackHead;
    head_l = new StackHead;
    tail = new Stack;
    tail_l = new Stack;
    head_r = new Stack;
    
    copy_head=0;
    copy_tail=0;
    num=0;
}

void Queue::Change()
{
    if(tail_l->top==0)
    {
        Stack* temp = tail;
        tail = tail_l;
        tail_l = temp;
    }
}

int Queue::Dequeue()
{
    int res = head->s[--head->top];
    head_r->dequeue++;
    Change();
    Copy();
    return res;
}

void Queue::Enqueue(int number)
{
    tail->s[tail->top++]=number;
    Change();
    num++;
    Copy();
}

void Queue::Judge()
{
    if(copy_tail==0&&tail_l->top>0&&head_l->top==0&&head_l->top_c==0) copy_tail=1;
    if(copy_tail==1&&tail_l->top==0) copy_tail=0;
    if(copy_head==0&&head->top_c>0) copy_head=1;
    if(copy_head==1&&head->top_c==0) copy_head=0;
}

void Queue::Copy()
{
    Judge();
    if(copy_tail==1)
    {
        head_l->s[head_l->top++] = tail_l->s[--tail_l->top];
        head_l->top_c++;
    }
    if(copy_head==1)
    {
        head_r->s[head_r->top++] = head->s[--head->top_c];
    }
    Judge();
    if(copy_head==0&&copy_tail==0)
    {
        if(head_r->top > head_r->dequeue)
        {
            head_l->s[head_l->top++]=head_r->s[--head_r->top];
            head_l->top_c++;
        }
        
        if(head_r->top == head_r->dequeue)
        {
            head_r->top=0;
            head_r->dequeue=0;
            
            head->top_c=0;
            head->top=0;
            
            StackHead* temp = head;
            head = head_l;
            head_l = temp;
        }
    }
}

int main()
{
    Queue s = Queue();
    
}

结语

理论上用了6个栈,实际上用了5个栈。

其实这个问题在实际中的应用中并没什么用。偶尔一次的O(n)效率的操作也无伤大雅,在大多数情况下。但是如果你遇到了无法承受任何一次O(n)操作的情况下,就可以想想如何把O(n)的操作给平均到每一步的操作中。

此外,偷梁换柱在上述过程也运用的炉火纯青。

最后,我们认为很简单的问题,往往深究下去,或者升级一下,会给我们带来更多。

参考资料

https://stackoverflow.com/questions/5538192/how-to-implement-a-queue-with-three-stacks

园子里的一篇文章

以上是关于用有限个栈模拟常数效率操作的队列的主要内容,如果未能解决你的问题,请参考以下文章

用2个栈实现队列

剑指offer:2个栈实现队列

用俩个栈实现队列

Java笔试模拟试题

算法_栈实现队列篇

算法_栈实现队列篇