数据结构——栈与队列（特详解），不会我亲自教你！！！

启示：
栈与队列
栈是限定仅在表位进行插入和删除操作的线性表
队列是只允许在一段进行插入操作，而在另一端进行删除操作的线性表

一、栈的定义

在我们软件应用中，栈这种先进先出的数据结构的应用是非常普遍的。比如你用手机浏览器上网时，不管什么浏览器都有一个“后退”键，你点击后可以按访问顺序的逆序加载浏览过的网页，比如你本来看着新闻好好的，突然看到一个链接说，有一个可以让你年薪100万的工作，你毫不犹豫点击它，跳转进去一看，这是啥呀，具体内容我也就不说了，骗人骗得一点水平都没有。此时你还想回去继续看新闻，就可以点击左下角的后退键。即使你从一个网页开始，连续点了几十个链接跳转，你点“后退”键时，还是可以像历史倒流一样，回到之前浏览过的某个页面。

栈（stack）是限定仅在表尾进行插入和删除操作的线性表

我们把允许插入和删除的一端成为栈顶（top），另一端称为栈底（boottom），不含任何数据元素的栈称为空栈。栈又称先进先出（Last In First Out）的线性表，简称LIFO结构。

它的特殊之处就在于限制了这个线性表的插入和删除的位置，它始终只在栈顶进行。这也就使得：栈底是固定的，最先进栈的只能在栈底。

栈的插入操作，叫做进栈，也称压栈、入栈。
栈的删除操作，叫做出栈，也有的叫弹栈。

二、进栈出栈变化形式

现在我要问问大家，这个最先进栈的元素，是不是就只能是最后出栈呢？

答案是不一定，要看什么情况。栈对线性表的插入和删除位置进行了限制，并没有对元素进出的时间进行限制，也就是说，在不是所有元素都进栈的情况下，事先进去的元素也可以出栈，只要保证是栈顶元素出栈就可以。

举例来说，如果我们现在是有三个整型数字1、2、3依次进栈，会有哪些出栈顺序呢？

第一种：1、2、3进，再1、2、3出。这是最简单的最好理解的一种，出栈次序为312.
第二种：1进，1出，2进，2出，3进，3出。也就是进一个就出一个，出栈次序为123.
第三种：1进，2进，2出，1出，3进，3出。出栈次序为213.
第四种：1进，1出，2进，3进，3出，2出。出栈次序为132.
第五种：1进，2进，2出，3进，3出，1出。出栈次序为231.

有没有可能是312这样的出栈次序呢？答案是肯定不会。因为3先出栈，就意味着，3曾经进栈，既然3都进栈了，那也就意味着，1和2已经进了栈，此时2一定是在1的上面，就是更接近栈顶，那么出栈只可能是321，不然不满足123依次进栈的要求，所以出栈的变化将会更多的。

三、栈的抽象数据类型

对于栈来讲，理论上线性表的操作特性它都具备，可由于它的特殊性，所以针对它在操作上会有些变化。特别是插入和删除操作，我们改名为 push 和 pop 英文直译的话是压和弹，更容易理解。我们一般都叫进栈和出栈。

ADT    //栈（stack）
Date 
       //同线性表。元素具有相同的类型，相邻元素具有前驱和后继关系。
Opreation
   InitStack(*S);           //初始化操作，建立一个空栈S
   DestroyStack(*S);        //若栈存在，则销毁它
   ClearStack(*S);          //将栈清空
   StackEmpty(S);           //若栈为空，返回true，否则返回false
   GetTop(S,*e);            //若栈存在且非空，用e返回S的栈顶元素
   Push(*S,e);              //若栈S存在，插入新元素e到栈S中并成为栈顶元素
   Pop(*S,*e);              //刪除栈S中栈顶元素,并用e返回其值。
   StackLength(S);         //返回栈S的元素个数。
 endADT

由于栈本身就是一个线性表,那么上一章我们讨论了线性表的顺序存储和链式存储,对于栈来说,也是同样适用的。

四、栈的顺序存储结构及实现

栈的顺序存储结构

既然栈是线性表的特例,那么栈的顺序存储其实也是线性表顺序存储的简化,我 们简称为顺序桟。线性表是用数组来实现的,想想看,对于栈这种只能一头插入刪除 的线性表来说,用数组哪一端来作为栈顶和栈底比较好？
对,没错,下标为0的一端作为栈底比较好,因为首元素都存在栈底,变化最 小,所以让它作栈底。
我们定义一个top变量来指示栈顶元素在数组中的位置,这top就如同中学物理 学过的游标卡尺的游标，它可以来回移动,意味着栈顶的top可以变大 变小,但无论如何游标不能超出尺的长度。同理,若存储栈的长度为StackSize,则栈顶top位置必须小于当栈存在一个元素时,top等于0,因此通常把空栈 的判定条件定为比？等于一 1。

来看栈的结构定义

typedef int SElemtype; // SElemtype类型根据实际情况而定，这里假设为int 
typedef struct{
SElemtype data[MAXSIZE];
int top;   //用于栈顶指针
}SqStack; 

若现在有一个栈，StackSize是5，则普通情况、空栈和满栈的情况如图所示

栈的顺序存储结构——进栈操作

对于栈的插入，即进栈操作，其实就是做了如下处理

因此对于进栈操作push，其代码如下：

/*插入元素e为新的栈顶元素*/
Status Push (SqStack *S, Selemtype e)
{
if(S->top== MAXSIE-1)   //栈满
{
 return ERROR;
}
 S->top++i;            //栈顶指针增加一
S-> data[s>top]=e;    //将新插入元素赋给栈顶空间
 return OK;
 }

栈的顺序存储结构——出栈操作

出栈操作pop，代码入下：

/*若栈不空，则删除的栈顶元素，用e返回其值，并返回OK;否则返回ERROR*/
Status Pop (SqStack *S, SElemtype *e)
{
if (S->top==-1)
retun ERROR;
*e=S->data[s->top];   /*将要删除的栈顶元素赋值给e */
S->top--;    //栈顶指针减一
return OK;
}

两者没有涉及到任何循环语句，因此时间复杂度均是0(1)

五、两栈共享空间

其实栈的顺序存储还是很方便的，因为它只准栈顶进出元素，所以不存在线性表插入和删除时需要移动元素的问题。不过它有一个很大的缺陷，就是必须事先确定数组存储空间大小，万一不够用了，就需要编程手段来扩展数组的容量，非常麻烦。对于个，我们也只能尽量考虑周全，设计出合适大小的数组来处理，但对于两个相同类型的，我们却可以做到最大限度地利用其事先开辟的存储空间来进行操作打个比方，两个大学室友毕业同时到北京工作，开始时，他们觉得住了这么多年学校的集体宿舍，现在工作了一定要有自己的私密空间。于是他们都希望租房时能找到独住的一居室，可找来找去却发现，最便宜的一居室也要每月1500元，地段还不好，实在是承受不起，最终他俩还是合租了一套两居室，一共2000元，各出一半，还不错。

对于两个一居室，都有独立的卫生间和厨房，是私密了，但大部分空间的利用率却不高。而两居室，两个人各有卧室，还共享了客厅、厨房和卫生间，房间的利用率就显著提高，而且租房成本也大大下降了。

同样的道理，如果我们有两个相同类型的栈，我们为它们各自开辟了数组空间极有可能是第一个栈已经满了，再进栈就溢出了，而另一个还有很多存储空间空闲。这又何必呢?我们完全可以用一个数组来存储两个栈，只不过需要点小技巧。

我们的做法如下图，数组有两个端点，两个栈有两个栈底，让一个栈的栈底为数组的始端，即下标为0处，另一个栈为栈的末端，即下标为数组长度n-1处。这样，两个栈如果增加元素，就是两端点向中间延伸。

其实关思路是:它们是在数组的两端，向中间靠拢。top1和top2是栈1和栈2的顶指针，可以想象，只要它们俩不见面，两个栈就可以一直使用。

从这里也就可以分析出来，栈1为空时，就是top1等干-1时；而当top2等于n时，即是栈2为空时，那什么时候栈满呢?

想想极端的情况，若栈2是空栈，栈1的op1等于n-1时，就是栈1满了。反之，当栈1为空栈时，top2等于0时，为栈2满。但更多的情况，其实就是我刚才说的，两个栈见面之时，也就是两个指针之间相差1时，即top1+1==top2为栈满。

便共享空间的结构的代码如下：

/*两共享空间结构*/

 typedef struct
{
 SElemType data [MAXSIZE);
  int top1;      //栈1 栈顶指针
  int top2;      //栈2 栈顶指针

 )SqDoubleStack;

对于两共享空可的push方法、我们除了要插入元素值参数外，还需要有一个判断是栈1还是栈2的栈号参数 stackNumber。插入元素的代码如下：

//插入元素e新的找顶元素
 Status Push (SqDoubleStack *S,SElemType e,int stackNumber)
 {
if(S->top1+1==S＞top2)  //栈已满，不能再Push新元素了
return ERROR;
if(stackNumber==1)
S->data[++S->top1]=e;   //若栈1  则先top1+1后给数组元素赋值
 else if(stackNumber==2)//栈2有元素进栈
S->data[--S-＞top2]=e;   //若栈2 则先top2-1后给数组元素赋值
 return OK;
 }

因为在开始已经判断了是否有满的情况，所以后面的top1+1或top2-1是不担心溢出问题的。

对于两桟共享空间的pop方法，参数就只是判断栈1栈2的参数 stackNumber，代码如下:

/*若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK;否则返回 ERROR*/
 Status Pop(SqDoubleStack *S, sElemType *e, int stackNumber)
 {
 if (stackNumber==1)
{
 if (S->top1==-1)
   return ERROR;   //说明栈1已经是空栈，溢出
 *e=S->data[S->top1--]; //将栈1的栈顶元素出栈
 }
 else if (stacknumber==2)
{
 if (S->top2==MAXSIZE)
  return ERROR;   //说明栈2已经是空栈，溢出
*e=->data[s-top2++];//将栈2的栈顶元素出栈
}
 return OK;
 }

事实上，使用这样的数据结构，通常都是当两个栈的空间需求有相反关系时，也就是一个找增长时另一个找在缩短的情况。就像买卖股票一样，你买入时，一定是有个你不知道的人在做卖出操作。有人赚钱，就一定是有人赔钱。这样使用两栈共享空间存储方法才有比较大的意义。否则两个栈都在不停地增长，那很快就会因满而溢出了。

当然，这只是针对两个具有相同数据类型的栈的一个设计上的技巧，如果是不相同数据类型的栈，这种办法不但不能更好地处理问题，反而会使问题变得更复杂，大家要注意这个前提。

六、栈的链式存储结构及实现

栈的链式存储结构

讲完了的顺序存储结构，我们现在来看栈的链式存储结构，简称为链栈。

想想看，栈只是栈顶来做插入和删除操作，栈顶放在链表的头部还是尾部呢?由于单链表有头指针，而栈顶指针也是必须的，那干吗不让它俩合二为一呢，所以比较好的办法是把栈顶放在单链表的头部。另外，都已经有了栈顶在头部了，单链表中比较常用的头结点也就失去了意义，通常对于链来说，是不需要头结点的。

对于链栈来说，基本不存在满栈的情况，除非内存没有可以使用的空间，如果真的发生，那此时的计算机操作系统已经面临死机崩溃的情况，而不是这个链栈是否溢出的问题。

但对于空栈来说，链表原定义是头指针指向空，那么链栈的空其实就是top=NULL的时候。

链栈的结构代码如下：

typedef struct StackNode
{
 SElemType data;
 struct StackNode *next;
 }StackNode,*LinkStackPtr;

typedef struct LinkStack
{
  LinkStackPtr  top;
  int count;
  }LinkStack;

链栈的操作绝大部分都和单链表类似，只是插入和删除上，特殊一些。

栈的链式存储结构——进栈操作

对于链式的进栈push操作，假设元素值为e的新结点为s，top为栈顶指针，如下图所示：

代码如下：

/*插入元素e为新的栈顶元素*/
Status Push(LinkStack *S,SElemType e)
{
 LinkStackPtr s=(LinkStackPtr)malloc(sizeof(StackNode));
 s->data=e;
 s->next=S->top;  //把当前的栈顶元素赋值给新结点的直接后继，如图中的1
 S->top=s;        //将新的结点s赋值给栈顶指针，如图中2
 S->count++;
 return OK;
 }

栈的链式存储结构——出栈操作

至于链栈的出栈pop操作，也是很简单的三句操作。假设变量p用来存储要删除的栈顶结点，将栈顶指针下移一位，最后释放即可，如下图所示：

/*若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR*/
Status Pop(LinkStack *S,SElemType *e)
{
  LinkStackPtr p;
  if(StackEmpty (*S) )
  return ERROR;
  *e=S->top->data;
  p=S->top;           //将栈顶结点赋值给p，如图3
  S->top=S->top->next;//使得栈顶指针下移一位，指向后一结点，如图4
  free(p);
  S->count--;
  return OK;
  }

链栈的进栈push和出栈pop操作都很简单，没有任何循环操作，时间复杂度均为O(1)。

对比一下顺序栈与链栈，它们在时间复杂度上是一样的，均为O(1)。对于空间性能，顺序栈需要事先确定一个固定的长度，可能会存在内存空间浪费的问题，但它的优势是存取时定位很方便，而链栈则要求每个元素都有指针域，这同时也增加了一些内存开销，但对于栈的长度无限制。所以它们的区别和线性表中讨论的一样，如果栈的使用过程中元素变化不可预料，有时很小，有时非常大，那么最好是用链栈，反之，如果它的变化在可控范围内，建议使用顺序栈会更好一些。

七、栈的作用

有的同学可能会觉得，用数组或链表直接实现功能不就行了吗?干吗要引入这样的数据结构呢?这个问题问得好。

其实这和我们明明有两只脚可以走路，干吗还要乘汽车、火车、飞机一样。理论上，陆地上的任何地方，你都是可以靠双脚走到的，可那需要多少时间和精力呢?我们更关注的是到达而不是如何去的过程。

栈的引入简化了程序设计的问题，划分了不同关注层次，使得思考范围缩小，更加聚焦于我们要解决的问题核心。反之，像数组等，因为要分散精力去考虑数组的下标增减等细节问题，反而掩盖了问题的本质。

所以现在的许多高级语言，比如Java、C＃等都有对栈结构的封装，你可以不用关注它的实现细节，就可以直接使用 Stack的push和pop方法，非常方便。

一、队列的定义

你们在用电脑时有没有经历过，机器有时会处于疑似死机的状态，鼠标点什么似乎都没用，双击任何快捷方式都不动弹。就当你失去耐心，打算了 reset时。突然它像酒醒了一样，把你刚点击的所有操作全部都按顺序执行了一遍。这其实是因为操作系统中的多个程序因需要通过一个通道输出，而按先后次序排队等待造成的。

再比如像移动、联通、电信等客服电话，客服人员与客户相比总是少数，在所有的客服人员都占线的情况下，客户会被要求等待，直到有某个客服人员空下来，才能让最先等待的客户接通电话。这里也是将所有当前拨打客服电话的客户进行了排队处理。

操作系统和客服系统中，都是应用了一种数据结构来实现刚才提到的先进先出的排队功能，这就是队列。

队列( queue)是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。

队列是一种先进先出(First In First Out)的线性表，简称FFO。允许插入的一端称为队尾，允许删除的一端称为队头。假设队列是q=(a1，a2，…，an)，那么a1就是队头元素，而an是队尾元素。这样我们就可以删除时，总是从a1开始，而插入时，列在最后。这也比较符合我们通常生活中的习惯，排在第一个的优先出列，最后来的当然排在队伍最后，如下图所示：

队列在程序设计中用得非常频繁。前面我们已经举了两个例子，再比如用键盘进行各种字母或数字的输入，到显示器上如记事本软件上的输出，其实就是队列的典型应用，假如你本来和女友聊天，想表达你是我的上帝，输入的是god，而屏幕上却显示出了dog发了出去，这真是要气死人了。

二、队列的抽象数据类型

同样是线性表，队列也有类似线性表的各种操作，不同的就是插入数据只能在队尾进行，删除数据只能在队头进行。

ADT队列( Queue)

 Data

   //同线性表。元素具有相同的类型，相邻元素具有前驱和后继关系。

 Operation

 InitQueue(*Q);//初始化操作，建立一个空队列Q。

 DestroyQueue(*Q);//若队列Q存在，则销毁它。

 ClearQueue(*Q);//将队列Q清空。

 QueueEmpty(Q);//若队列Q为空，返回true，否则返回fase

 GetHead(Q，*e);//若队列Q存在且非空，用返回队列Q的队头元素。

 EnQueue(*Q,e);//若队列Q存在，插入新元素e到队列Q中并成为队尾元素。

 DeQueue(*Q，*e);//删除队列Q中队头元素，并用e返回其值。

 QueueLength(Q);//返回队列Q的元素个数

 endADT

三、循环队列

线性表有顺序存储和链式存储，栈是线性表，所以有这两种存储方式。同样，队列作为一种特殊的线性表，也同样存在这两种存储方式。我们先来看队列的顺序存储结构。

队列顺序存储的不足

我们假设一个队列有n个元素，则顺序存储的队列需建立一个大于n的数组，并把队列的所有元素存储在数组的前n个单元，数组下标为0的一端即是队头。所谓的入队列操作，其实就是在队尾追加一个元素，不需要移动任何元素，因此时间复杂度为O（1），如下图所示：

与栈不同的是，队列元素的出列是在队头，即下标为0的位置，那也就意味着，队列中的所有元素都得向前移动，以保证队列的队头，也就是下标为0的位置不为空，此时时间复杂度为(n)，如下图所示：

这里的实现和线性表的顺序存储结构完全相同，不再详述。

在现实中也是如此，一群人在排队买票，前面的人买好了离开，后面的人就要全部向前一步，补上空位，似乎这也没什么不好。

可有时想想，为什么出队列时一定要全部移动呢，如果不去限制队列的元素必须存储在数组的前n个单元这一条件，出队的性能就会大大増加。也就是说，队头不需要一定在下标为0的位置，如下图所示：

为了避免当只有一个元素时，队头和队尾重合使处理变得麻烦，所以引入两个指针， front指针指向队头元素，rear指针指向队尾元素的下一个位置，这样当 front等于rear时，此队列不是还剩一个元素，而是空队列。

假设是长度为5的数组，初始状态，空队列如下图的左图所示， front与rear指针均指向下标为0的位置。然后入队a1、a2、a3、a4， front指针依然指向下标为0位置，而rear指针指向下标为4的位置，如下图4 的右图所示：

出队a1、a2，则 front指针指向下标为2的位置，rear不变，如下图的左图所示，再入队a5，此时 front指针不变，rear指针移动到数组之外。嗯?数组之外，那将是哪里?如下图5 的右图所示：

问题还不止于此。假设这个队列的总个数不超过5个，但目前如果接着入队的话，因数组末尾元素已经占用，再向后加，就会产生数组越界的错误，可实际上，我们的队列在下标为0和1的地方还是空闲的。我们把这种现象叫做“假溢出”。

现实当中，你上了公交车，发现前排有两个空座位，而后排所有座位都已经坐满，你会怎么做?立马下车，并对自己说，后面没座了，我等下一辆?

没有这么笨的人，前面有座位，当然也是可以坐的，除非坐满了，会考虑下
辆。

循环队列定义

所以解决假溢出的办法就是后面满了，就再从头开始，也就是头尾相接的循环。我们把队列的这种头尾相接的顺序存储结构称为循环队列。

刚才的例子继续，上图5的rear可以改为指向下标为0的位置，这样就不会造成指针指向不明的问题了，如下图6所示：

接着入队a6，将它放置于下标为0处，rear指针指向下标为1处，如下图的左图所示。若再入队a，则rear指针就与 front指针重合，同时指向下标为2的位置，如下图7 的右图所示。

此时问题又出来了，我们刚才说，空队列时，font等于rear，现在当队列满时，也是 front等于rear，那么如何判断此时的队列究竟是空还是满呢?

办法一 ：是设置一个标志变量flag，当front==rear，且flag=0时为队列空，

当 front== rear，且flag=1时为队列满。

办法二是当队列空时，条件就是 front=rear，当队列满时，我们修改其条件，保留一个元素空间。也就是说，队列满时，数组中还有一个空闲单元。例如下图8 所示，我们就认为此队列已经满了，也就是说，我们不允许上图7 的右图情况出现。

我们重点来讨论第二种方法，由于rear可能比 front大，也可能比 front小，所以尽管它们只相差一个位置时就是满的情况，但也可能是相差整整一圈。所以若队列的最大尺寸为 Queuesize，那么队列满的条件是(rear+1)％ Queuesize== front(取模“％”的目的就是为了整合rear与 front大小为一个问题)。比如上面这个例子，Queuesize=5，上图的左图中 front=0，而rear=4，(4+1)％5=0，所以此时队列满。再比如图上中的右图， front=2而rear=1。(1+1)％5=2，所以此时队列也是满的。而对于图6 front=2而rear=0，(0+1)％5=1，1≠2，所以此时队列并没有满。

另外，当rear＞ front时，即图4的右图和5的左图，此时队列的长度为rear- front。但当 rear＜ front时，如图6和图7的左图，队列长度分为两段，一段是 Queuesize- front，另一段是0+rear，加在一起，队列长度为rear front+ Queuesize。因此通用的计算队列长度公式为
(rear-front+Queuesize) %Queuesize

有了这些讲解，现在实现循环队列的代码就不难了。循环队列的顺序存储结构代码如下：

 typedef int QElemType;  // QElemType类型根据实际情而定，这里设为int
 //循环队列的顺序存储结构 
 typedef struct
{
 QElemType data [MAXSIZE]);
  int front;  //头指针
  int rear;   //尾指针，若队列不空，指向队列尾元素的下一个位置
} SqQueue;

循环队列的初始化代码如下：

/*初始化一个空队列Q*/
Status InitQueue(SqQueue *Q)
{
  Q->front=0;
  Q->rear=0;
  return OK;
  }

循环队列求队列长度代码如下：

/*返回Q的元素个数，也就是队列的当前长度*/
int QueueLength(SqQueue Q)
{
  return (Q.rear-Q.front+MAXSIZE)%MAXSIZE;
  }

循环队列的入队列操作代码如下：

/*若队列未满，则插入元素e为Q新的队尾元素*/
Status EnQueue(SqQueue *Q,QElemType e)
{
 if( (Q->rear+1)%MAXSIZE == Q->front)  //队列满的判断
 return ERROR;
 Q->data[Q->rear]=e;    //将元素e赋值给队尾
 Q->rear=(Q->rear+1)%MAXSIZE;  //rear指针向后移一位置
 return OK;
 }

循环队列的出队列操作代码如下：

/*若队列不空，则删除Q中对头元素，用e返回其值*/
Status DeQueue(SqQueue *Q,QElemType e)
{
  if(Q->front==Q->rear)     //队列空的判断
  return ERROR;
  *e=Q->data[Q->front];     //将队头元素赋值给e
  Q->front=(Q->front+1)%MAXSIZE;  //front指针向后移一位置
                                  //若到最后则转到数组头部
  return OK;
  }

从这一段讲解，大家应该发现，单是顺序存储，若不是循环队列，算法的时间性能是不高的，但循环队列又面临着数组可能会溢出的问题，所以我们还需要研究一下不需要担心队列长度的链式存储结构。 (见下一期）

总结回顾

我们这一章讲的是栈和队列，它们都是特殊的线性表，只不过对插入和删除操作做了限制。

栈(Stack)是限定仅在表尾进行插入和删除操作的线性表。

队列( queue)是只允许在一端进行插入操作，而在另一端进行删除操作的线性

它们均可以用线性表的顺序存储结构来实现，但都存在着顺序存储的一些弊端。

因此它们各自有各自的技巧来解决这个问题。

对于栈来说，如果是两个相同数据类型的栈，则可以用数组的两端作栈底的方法来让两个共享数据，这就可以最大化地利用数组的空间。

对于队列来说，为了避免数组插入和删除时需要移动数据，于是就引入了循环队列，使得队头和队尾可以在数组中循环变化。解决了移动数据的时间损耗，使得本来插入和删除是O(的时间复杂度变成了(1)。

（借鉴于大话数据结构）

留关注，不迷路！！！