数据结构栈和队列

SLY司赖

已于 2022-10-06 21:44:28 修改

阅读量731

点赞数 9

分类专栏： DS 文章标签：数据结构栈队列数组

于 2022-10-05 21:23:24 首次发布

本文链接：https://blog.csdn.net/weixin_46516647/article/details/127165251

版权

DS 专栏收录该内容

7 篇文章 2 订阅

订阅专栏

重点掌握栈的出入过程，出栈序列的合法性以及队列的操作和特征

3.1 栈

3.1.1 基本概念

·Def：栈是只允许在一端进行插入或删除操作的线性表

·栈顶Top：又称为表尾，进行插入删除操作的一端

·栈底Bottom：又称表头，固定端，不允许插入删除操作的一端

·特点：只能在栈顶进行运算，访问结点按后进先出last in first out原则

·逻辑结构：与线性表相同，仍为一对一的关系

·基本操作：

InitStack(&S):初始化一个空栈S

StackEmpty(S):判断一个栈是否为空，若栈S为空则返回true,否则返回false

Push(&S,x):进栈，若栈s未满，则将x加入使之成为新栈顶

Pop(&S,&x):出栈，若栈s非空，则弹出栈顶元素，并用x返回

GetTop(S,&x):读栈顶元素，若栈s非空，则用x返回栈顶元素

DestroyStack(&S):销毁栈，并释放栈s占用的存储空间(“ &”表示引用调用)

3.1.2 栈的顺序存储结构

·顺序栈：采用顺序存储的栈称为顺序栈，与一般线性表顺序存储结构完全相同，利用一组地址连续的存储单元依次存放自栈底到栈顶的元素，用top指针指向栈顶（或栈顶元素之上的下标地址）

·特点：使用数组作为顺序栈简单，方便，但是数组大小固定易产生溢出（上溢：栈满继续push；下溢：栈空还要pop，下溢可以作为一种结束条件使用）

·顺序栈的实现

1）初始化：初始化栈顶指针S.top=-1

2）判栈空：S.top=-1时栈为空，否则不空

3）进栈：栈不满时，栈顶指针先加1，再送值到栈顶

bool Push (SqStack &S, ElemType x) {
    if (S. tope=MaxSize-1)         //栈满， 报错
        return false;
    S.data[++S.top]=x;             //指针先加1,再入栈
    return true ;
}

4）出栈：栈非空时，先取栈顶元素值，再将栈顶指针减1

bool Pop (SqStack &S, ElemType &x) {
    if(S. top==-1)              //栈空，报错
      return false;
    x=S.data[S.top--];          //先出栈，指针再减1
    return true;
}

5）读栈顶元素

bool GetTop (SqStack S, ElemType &x) {
    if(S. top==-1)                //栈空，报错
      return false;
    x=S .data[S.top];             //x记录栈顶元素
    return true ;
}

·共享栈：利用栈底位置相对不变，可让两个顺序栈共享一个一维数组，将两个栈的栈底分别设置在共享空间的两端，两个栈顶向共享空间的中间延伸

两个栈的栈顶指针都指向栈顶元素，top1=-1 时1号栈为空，top2=Maxsize时 2号栈为空；仅当两个栈顶指针相邻(top2-top1=1)时，判断为栈满。当1号栈进栈时top1先加1再赋值，2号栈进栈时top2先减1再赋值；出栈时则刚好相反。

共享栈是为了更有效地利用存储空间，两个栈的空间相互调节，只有在整个存储空间被占满时才发生上溢。其存取数据的时间复杂度均为0(1)，所以对存取效率没有什么影响。

3.1.3 栈的链式存储结构

·链栈：采用链式存储的栈称为链栈，通常采用单链表实现，且所有操作都是在表头进行的，因此链栈没有头结点，头指针直接指向栈顶元素

·特点：链栈便于多个栈共享存储空间提高了效率，且不存在栈满上溢的情况，便于结点的删除插入操作；链栈的操作与链表类似，出栈入栈都在表头进行

·链栈的基本操作

1）初始化：构造一个空栈，栈顶指针置为空

2）判空：Lhead=NULL？

3）入栈

4）出栈

5）取栈顶元素：直接return Lhead->data

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

3.2 队列

3.2.1 基本概念

·Def：队列是只允许在一端（队尾）进行插入，而在另一端进行删除（队头）操作的线性表（想想排队做核酸的队列），即一种先进先出的线性表

·队列基本操作：

InitQueue(&Q):初始化队列，构造一个空队列Q

QueueEmpty(Q):判队列空，若队列Q为空返回true,否则返回false

EnQueue(&Q,x):入队，若队列Q未满，将x加入，使之成为新的队尾

DeQueue (&Q,&x):出队，若队列Q非空，删除队头元素，并用x返回

GetHead(Q, &x):读队头元素，若队列e非空，则将队头元素赋值给x

【注】：不可以随便读取栈或队列中间的某个数据

3.2.2 队列的顺序存储

·Def：队列的顺序存储是指分配一块连续的存储单元存放队列中的元素，并设两个指针:队头指针front指向队头元素以及队尾指针rear指向队尾元素的下一个位置(不同教材对front和rear的定义可能不同，可以让rear指向队尾元素、front 指向队头元素）

·顺序存储描述类型：

#define MaxSize 50         //定义队列中元素的最大个数
typedef struct{
ElemType data [MaxSize] ; //存放队列元素
int front, rear;          //队头指针和队尾指针
} SqQueue;

·队列的操作：

初始状态(队空): Q. front==Q. rear==0

进队操作：队不满时，先送值到队尾元素，再将队尾指针加1

出队操作：队不空时，先取队头元素值，再将队头指针加1

【注】：当rear==maxQsize时，发生的真溢出和假溢出

·循环队列：针对上述的真假溢出情况，解决方法是后面满了再从头开始，将上图的rear指针指向0的位置，这样头尾相接的循环，即把存储队列元素的表从逻辑上视为一个环，称为循环队列，也可抽象成一个圆形队列

·循环队列的实现：利用模运算，实现rear指针指向0，即插入元素时Q.rear = (Q.rear+1) % MAXQSIZE，这样rear指针就能从最后一个位置移动到第一个位置；删除元素时front指针同理，Q.front = (Q.front+1) % MAXQSIZE

·循环队列判空判满：对下图，此时队空队满都是rear=front，那如何判断此时到底是空还是满呢？

1）设置一个标志flag，当rear=front且flag=0时队为空；rear=front且flag=1时队满

2）另设一个变量，记录队中的元素个数

3）少用一个元素空间。由于rear可能比front大也可能小，可能相差一个位置，也可能相差一圈，即下图两种情况，所以为了解决rear和front的大小问题，队满的条件就为 (rear+1) % MAXQSIZE=front；队空条件仍为rear=front

综上还可以计算出队列中的元素个数为：(rear-front+ MAXQSIZE)% MAXQSIZE，有了以上分析，实现循环队列的基本思想就有了

·循环队列的基本操作

1）初始化：初始化队首队尾指针Q.rear =Q.front=0

2）判队空：Q.rear =Q.front

3）入队

bool EnQueue (SqQueue &Q，ElemType x) {
    if((Q. rear+1) %MaxSize==Q. front) return false;  //队满则报错
    Q.data[Q. rear]=x;
    Q. rear= (Q. rear+1) MaxSize;                    //队尾指针加1取模
    return true;
}

4）出队

bool DeQueue (SqQueue &Q, ElemType &X) {
    if(Q. rear==Q. front) return false;         //队空则报错
    x=Q. data[Q. front] ;
    Q. front= (Q. front+1)%MaxSize;            //队头指针加1取模
    return true;
}

3.2.3 队列的链式存储

·Def：队列的链式存储称为链队列，是一个同时带有队头指针和队尾指针的单链表，队头指针指向队列头结点，队尾指针指向终端结点，队空时front和rear都指向头结点

·链队列的基本操作

1）初始化：建立头结点，置队头指针为空Q.front->next=NULL

2）判空：Q.front=Q.rear

3）入队：将新结点插入到链尾

void EnQueue (LinkQueue &Q, ElemType x) {
    LinkNode *s= (LinkNode*) malloc (sizeof (LinkNode)) ;
    s->data=x; s->next=NULL;            //创建新结点，插入到链尾
    Q. rear->next=s;
    Q. rear=s;
}

4）出队：删除链表第一个结点

bool DeQueue (LinkQueue &Q; ElemType &x) {
    if (Q. front--Q.rear) return false;         //空队
    LinkNode *p=Q. front->next;
    x=p->data;
    Q. front->next=p->next;
    if (Q. rear==p)
      Q. rear=Q. front;                //若原队列中只有一个结点，删除后变空
    free(p) ;
    return true;
}

3.2.4 双端队列

·Def：双端队列指允许两端都可以进行入队和出队操作的队列，其逻辑结构仍为线性结构

·输出受限的双端队列：一端允许入队和出队，但另一端只允许入队的双端（两入一出），针对两入一出的双端队列，在进行入出队顺序时抓住“两边进依次出”的准则

·输入受限的双端队列：一端允许入队和出队，但另一端只允许出队的双端（两出一入），针对两出一入的双端队列，在进行入出队顺序时抓住“依次进两边出出”的准则