数据结构——栈与队列（顺序栈、链栈、循环队列、链队列）

提示：以下内容不适合零基础人员，仅供笔者复习之用。

概要：

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

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

一、栈

1. 定义

    栈是限定仅在表尾进行插入和删除操作的线性表。（又称后进先出的线性表）

2. 抽象数据类型

3. 栈的顺序存储结构及实现

#define MAXSIZE 20 /* 存储空间初始分配量 */typedef int Status; typedef int SElemType; /* SElemType类型根据实际情况而定，这里假设为int *//* 顺序栈结构 */typedef struct{        SElemType data[MAXSIZE];        int top; /* 用于栈顶指针 */}SqStack;

栈的普通情况、空栈、栈满情况：（注意top值）

3.1 操作

#include "stdio.h"    #include "stdlib.h"   #include "io.h"  #include "math.h"  #include "time.h"#define OK 1#define ERROR 0#define TRUE 1#define FALSE 0#define MAXSIZE 20 /* 存储空间初始分配量 */typedef int Status; typedef int SElemType; /* SElemType类型根据实际情况而定，这里假设为int *//* 顺序栈结构 */typedef struct{        SElemType data[MAXSIZE];        int top; /* 用于栈顶指针 */}SqStack;Status visit(SElemType c){        printf("%d ",c);        return OK;}/*  构造一个空栈S */Status InitStack(SqStack *S){         /* S.data=(SElemType *)malloc(MAXSIZE*sizeof(SElemType)); */        S->top=-1;        return OK;}/* 把S置为空栈 */Status ClearStack(SqStack *S){         S->top=-1;        return OK;}/* 若栈S为空栈，则返回TRUE，否则返回FALSE */Status StackEmpty(SqStack S){         if (S.top==-1)                return TRUE;        else                return FALSE;}/* 返回S的元素个数，即栈的长度 */int StackLength(SqStack S){         return S.top+1;}/* 若栈不空，则用e返回S的栈顶元素，并返回OK；否则返回ERROR */Status GetTop(SqStack S,SElemType *e){        if (S.top==-1)                return ERROR;        else                *e=S.data[S.top];        return OK;}/* 插入元素e为新的栈顶元素 */Status Push(SqStack *S,SElemType e){        if(S->top == MAXSIZE -1) /* 栈满 */        {                return ERROR;        }        S->top++;/* 栈顶指针增加一 */        S->data[S->top]=e;  /* 将新插入元素赋值给栈顶空间 */        return OK;}/* 若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR */Status Pop(SqStack *S,SElemType *e){         if(S->top==-1)                return ERROR;        *e=S->data[S->top];/* 将要删除的栈顶元素赋值给e */        S->top--;/* 栈顶指针减一（重要） */        return OK;}/* 从栈底到栈顶依次对栈中每个元素显示 */Status StackTraverse(SqStack S){        int i;        i=0;        while(i<=S.top)        {                visit(S.data[i++]);        }        printf("\n");        return OK;}int main(){        int j;        SqStack s;        int e;        if(InitStack(&s)==OK)                for(j=1;j<=10;j++)                        Push(&s,j);        printf("栈中元素依次为：");        StackTraverse(s);        Pop(&s,&e);        printf("弹出的栈顶元素 e=%d\n",e);        printf("栈空否：%d(1:空 0:否)\n",StackEmpty(s));        GetTop(s,&e);        printf("栈顶元素 e=%d 栈的长度为%d\n",e,StackLength(s));        ClearStack(&s);        printf("清空栈后，栈空否：%d(1:空 0:否)\n",StackEmpty(s));                return 0;}

3.2 两栈共享空间

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

形成的新数组：0、1、2、……n-2、n-1

使用场景：两个栈的空间需求有相反关系时，即一个栈增长另一个栈缩短时。（就像买股票，有人买入就定有人卖出）

使用前提：两个具有相同数据类型的栈。

关键：top1和top2是栈1和栈2的栈顶指针，只要他两不相见，两个栈就可以一直使用。

结构分析

• 空栈：栈1为空时，top1=-1。栈2为空时，top2=n。

• 满栈：极端情况下，栈2为空，则栈1 的top1=n-1时，栈1满了；反之，栈1为空，则栈2的top2=0时，栈2满了。一般情况下，两个栈见面时，即top1+1=top2时，可认为栈满。
  

结构代码：

#define MAXSIZE 20 /* 存储空间初始分配量 */typedef int Status; typedef int SElemType; /* SElemType类型根据实际情况而定，这里假设为int *//* 两栈共享空间结构 */typedef struct {        SElemType data[MAXSIZE];        int top1;/* 栈1栈顶指针 */        int top2;/* 栈2栈顶指针 */}SqDoubleStack;

插入：

/* 插入元素e为新的栈顶元素，stackNumber用于判定是栈1还是栈2 */Status Push(SqDoubleStack *S,SElemType e,int stackNumber){        if (S->top1+1==S->top2)/* 栈已满，不能再push新元素了（防止溢出） */                return ERROR;        if (stackNumber==1)/* 栈1有元素进栈 */                S->data[++S->top1]=e; /* 若是栈1则先top1+1后给数组元素赋值。 */        else if (stackNumber==2)/* 栈2有元素进栈 */                S->data[--S->top2]=e; /* 若是栈2则先top2-1后给数组元素赋值。 */        return OK;}

删除：（栈顶元素）

/* 若栈不空，则删除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=S->data[S->top2++]; /* 将栈2的栈顶元素出栈 */        }        return OK;}

4. 栈的链式存储结构及实现

状态分析：

基本不存在栈满（溢出）的情况，除非内存已没有可用空间，此时计算机系统已近崩溃。

链栈为空，top=NULL;

结构代码：

/* 链栈结构 */typedef struct StackNode{        SElemType data;        struct StackNode *next;}StackNode,*LinkStackPtr;typedef struct{        LinkStackPtr top;        int count;}LinkStack;

链栈的操作绝大部分都和单链表相似，只是在插入、删除上，特殊点。

进栈：

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

出栈（删除）：

/* 若栈不空，则删除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，见图中③ */        S->top=S->top->next;    /* 使得栈顶指针下移一位，指向后一结点，见图中④ */        free(p);                    /* 释放结点p */                S->count--;        return OK;}

5. 顺序栈和链栈的对比

相同点：时间复杂度上一样，均为O（1）。

不同点：空间性能上

             顺序栈

                       优点：存取时定位方便。

                       缺点：需要事先确定一个固定的长度，可能会存在内存空间浪费的问题。

             链栈

                       优点：对栈长度无限制。

                       缺点：要求每个元素都有指针域，增加了内存开销。

        综上，如果栈的使用过程中元素变化不可预料，有时很小有时非常大，那么最好使用链栈。反之，如果它的变化在可控范围内，建议使用顺序栈会更好一些。

二、队列

1. 定义

    只允许在一端进行插入操作，而在另一端进行删除操作的线性表。

2. 抽象数据类型

3. 循环队列

3.1 队列顺序存储的不足

    插入元素时间复杂度为O（1），删除时是O（n），因为后面的所有元素要向前移;

    引入front指针和rear指针，前者指向队头元素，后者指向队尾元素的下一个位置。如图：

    若a1，a2出队，此时队头有空闲，队尾插入元素会导致“假溢出”，如图：

    此时，引入循环队列的概念：把队列的头尾相接的顺序存储结构称为循环队列。

    由于rear可能比front大，也可能小，所以尽管它们只差一个位置就是满的情况，但也可能是相差整整一圈。所以若队列的最大尺寸为QueueSize，那么队列满的条件是(rear+1)%QueueSize == front。考虑到rear>front和rear<front的情况，通用的队列长度计算公式为：(rear-front+QueueSize)%QueueSize。

3.2 代码实现

3.2.1 循环队列的顺序存储结构

#define OK 1#define ERROR 0#define TRUE 1#define FALSE 0#define MAXSIZE 20 /* 存储空间初始分配量 */typedef int Status; typedef int QElemType; /* QElemType类型根据实际情况而定，这里假设为int *//* 循环队列的顺序存储结构 */typedef struct{    QElemType data[MAXSIZE];    int front;        /* 头指针 */    int rear;        /* 尾指针，若队列不空，指向队列尾元素的下一个位置 */}SqQueue;

3.2.2 循环队列初始化

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

3.2.3 循环队列求长度

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

3.2.4 入队

/* 若队列未满，则插入元素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;}

3.2.5 出队

/* 若队列不空，则删除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;}

4. 链队列

4.1 定义

    队列的链式存储结构，其实就是线性表的单链表，只不过它只能尾进头出而已，简称为链队列。为了操作方便，我们将头指针指向链队列的头结点，队尾指针指向终端结点。

    空队列时，front和rear都指向头结点。

   

    链队列的结构：

#define OK 1#define ERROR 0#define TRUE 1#define FALSE 0#define MAXSIZE 20 /* 存储空间初始分配量 */typedef int Status; typedef int QElemType; /* QElemType类型根据实际情况而定，这里假设为int */typedef struct QNode/* 结点结构 */{   QElemType data;   struct QNode *next;}QNode,*QueuePtr;typedef struct/* 队列的链表结构 */{   QueuePtr front,rear; /* 队头、队尾指针 */}LinkQueue;

4.2 操作

4.2.1 入队

    入队操作，就是链表尾部插入结点。

/* 插入元素e为Q的新的队尾元素 */Status EnQueue(LinkQueue *Q,QElemType e){ QueuePtr s=(QueuePtr)malloc(sizeof(QNode));if(!s) /* 存储分配失败 */exit(OVERFLOW);s->data=e;s->next=NULL;Q->rear->next=s;/* 把拥有元素e的新结点s赋值给原队尾结点的后继，见图中① */Q->rear=s;/* 把当前的s设置为队尾结点，rear指向s，见图中② */return OK;}

4.2.2 出队

    头结点的后继结点出队，将头结点的后继改为它后面的结点。若链表除头结点外只剩一个元素时，则需将rear指向头结点。

/* 若队列不空,删除Q的队头元素,用e返回其值,并返回OK,否则返回ERROR */Status DeQueue(LinkQueue *Q,QElemType *e){QueuePtr p;if(Q->front==Q->rear)return ERROR;p=Q->front->next;/* 将欲删除的队头结点暂存给p，见图中① */*e=p->data;/* 将欲删除的队头结点的值赋值给e */Q->front->next=p->next;/* 将原队头结点的后继p->next赋值给头结点后继，见图中② */if(Q->rear==p)/* 若队头就是队尾，则删除后将rear指向头结点，见图中③ */Q->rear=Q->front;free(p);return OK;}

5 循环队列和链队列的比较

    时间上，基本操作都是常数时间，即O（1）,不过，循环队列是事先申请好空间，使用期间不释放，而对于链队列，每次申请和释放结点会存在一些时间开销，如果入队出队频繁，则两者还是略有差异。

    空间上，循环队列必须有固定的长度，所以就有了存储元素个数和空间浪费的问题。而链队列不存在这样的问题，尽管它需要一个指针域，会产生一些空间上的开销，但也可以接受。所以在空间上，链队列更加灵活。

    总之，在可以确定队列长度最大值的情况下，建议用循环队列，如果无法预估队列的长度，则用链队列。

6 总结

   

    其中，循环队列是为了避免数组插入和删除数据时需要移动数据而引入的。

参考：

《大话数据结构》