【数据结构】队列

写在前面

本篇文章的行文脉络为

1. 队列的基本概念

2. 队列的结构存储结构

3. 队列的基本操作

4. 队列的综合应用

---

先识概念

1. 队列是一种先进先出的数据结构。队列（queue）是限定在表的一端进行插入，表的另一端进行删除的数据结构

2. 队列可以使用顺序表实现，也可以使用链表实现，下面会逐一进行讲解

3. 使用顺序队列——一般都是循环队列，如果无法预估队列的最大长度，则宜采用链队

4. 更多概念知识还是翻书为妙

---

再看思想

顺序存储结构

typedef int ElemType;
//队列的顺序存储结构
typedef struct
{
    ElemType data[MAXSIZE];
    int front;
    int rear;
}SqQueue;

链式存储结构

typedef int ElemType;
//队列的链式存储结构
typedef struct QNode   //结点的结构体
{
    ElemType data;
    struct QNode* next;
}QNode, * QueuePtr;

typedef struct       //链队的结构体
{
    QueuePtr front;
    QueuePtr rear;
}LinkQueue;

入栈出栈操作

#define MAXSIZE 100
#define OK 1
#define ERROR 0

typedef int Status;
typedef int ElemType;

//顺序队列入队
Status EnQueue(SqQueue* Q, ElemType e)
{
    if ((Q->rear + 1) % MAXSIZE == Q->front)
        return ERROR;
    Q->data[Q->rear] = e;
    Q->rear = (Q->rear + 1) % MAXSIZE;
    return OK;
}
/*
1.简单起见，顺序队列不考虑扩容，要想入队，首先要判断队列是否已满，(Q->rear + 1) % MAXSIZE == Q->front，就是判断队列是否已满的公式（队列尾指针+1）%数组长度==队列头指针
2.未满就将要入队的元素赋给头指针所指向的空间
3.之后让头指针指向下一个元素， Q->rear = (Q->rear + 1) % MAXSIZE;
    没错和上面的公式一样，(Q->rear + 1) % MAXSIZE就是循环队列让指针指向下一块空间的方法
*/

//顺序队列出队
Status DeQueue(SqQueue* Q, ElemType* e)
{
    if (Q->front == Q->rear)
        return ERROR;
    *e = Q->data[Q->front];
    Q->front = (Q->front + 1) % MAXSIZE;
    return OK;
}
/*
1.如果头尾指针重合，那么说明队列为空，就没有必要出队了
2.如果队列之中有元素，那么保存队头指针所指向的元素
3.之后让队头指针指向下一块空间即可
*/

//链队列入队——尾插法
Status EnLinkQueue(LinkQueue* Q, ElemType e)
{
    QueuePtr S = (QueuePtr)malloc(sizeof(QNode));
    if (!S)
        exit(-1);
    S->data = e;
    S->next = NULL;
    Q->rear->next = S;
    Q->rear = S;
    return OK;
}
/*
既然是用链表实现的，自然就是使用链表的一些基本操作，下面会对队列进行初始化，这里就假设已经初始化了，并且链表有头结点,front和rear都指向头结点
1.首先声明一个结点指针S，并开辟一块空间，让要入队的元素赋值给数据域，并把指针域置空
2.接着将队列的队尾指针Q的指针域指向S，并使S成为新的队尾指针
*/

//出队
Status DeLinkQueue(LinkQueue* Q, ElemType* e)
{
    QueuePtr p;
    if (Q->front == Q->rear)
        return ERROR;
    p = Q->front->next;
    *e = p->data;
    Q->front->next = p->next;
    if (Q->rear == p)
        Q->rear = Q->front;
    free(p);
    return OK;
}
/*
1.出队自然就得先判断是否是空队列，头尾指针重合就是空队列
2.接着声明一指针p指向头结点的下一个结点，并将此结点数据域用e保存，
3.让头结点的指针域指向p的下一个结点，并把p结点释放掉
4.如果要出队的结点是最后一个结点，出队完后，得让尾指针和头指针重合
*/

---

后学应用

循环队列的应用

#define _CRT_SECURE_NO_WARNINGS 1

#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>

#define MAXSIZE 100
#define OK 1
#define ERROR 0

typedef int Status;
typedef int ElemType;


//队列的顺序存储结构
typedef struct
{
    ElemType data[MAXSIZE];
    int front;
    int rear;
}SqQueue;

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

//入队
Status EnQueue(SqQueue* Q, ElemType e)
{
    if ((Q->rear + 1) % MAXSIZE == Q->front)
        return ERROR;
    Q->data[Q->rear] = e;
    Q->rear = (Q->rear + 1) % MAXSIZE;
    return OK;
}

//出队
Status DeQueue(SqQueue* Q, ElemType* e)
{
    if (Q->front == Q->rear)
        return ERROR;
    *e = Q->data[Q->front];
    Q->front = (Q->front + 1) % MAXSIZE;
    return OK;
}

//求队列的长度
int QueueLength(SqQueue Q)
{
    return (Q.rear - Q.front + MAXSIZE) % MAXSIZE;
}

int main()
{
    int i;
    SqQueue Q;
    ElemType e;
    InitQueue(&Q);
    printf("请输入5个整数入队：");
    for (i = 0; i < 5; i++)
    {
        scanf("%d", &e);
        EnQueue(&Q, e);
    }

    printf("队列的长度为：");
    int ret = QueueLength(Q);
    printf("%d\n", ret);

    printf("请输入一个要入队的整数：");
    scanf("%d", &e);
    EnQueue(&Q, e);

    printf("依次出队为：");
    for (i = 0; i < 6; i++)
    {
        DeQueue(&Q, &e);
        printf("%d ", e);
    }

    return 0;
}

链队列的应用

#define _CRT_SECURE_NO_WARNINGS 1

#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>

#define MAXSIZE 100
#define OK 1
#define ERROR 0

typedef int Status;
typedef int ElemType;


//队列的链式存储结构
typedef struct QNode   //结点的结构体
{
    ElemType data;
    struct QNode* next;
}QNode, * QueuePtr;

typedef struct       //链队的结构体
{
    QueuePtr front;
    QueuePtr rear;
}LinkQueue;

//初始化
Status InitLinkQueue(LinkQueue* Q)
{
    Q->front = Q->rear = (QueuePtr)malloc(sizeof(QNode));
    if (!Q->front)
        exit(-1);
    Q->front->next = NULL;
    return OK;
}

//入队——尾插法
Status EnLinkQueue(LinkQueue* Q, ElemType e)
{
    QueuePtr S = (QueuePtr)malloc(sizeof(QNode));
    if (!S)
        exit(-1);
    S->data = e;
    S->next = NULL;
    Q->rear->next = S;
    Q->rear = S;
    return OK;
}

//出队
Status DeLinkQueue(LinkQueue* Q, ElemType* e)
{
    QueuePtr p;
    if (Q->front == Q->rear)
        return ERROR;
    p = Q->front->next;
    *e = p->data;
    Q->front->next = p->next;
    if (Q->rear == p)
        Q->rear = Q->front;
    free(p);
    return OK;
}

//销毁链队列
Status DestroyLinkQueue(LinkQueue* Q)
{
    while (Q->front)
    {
        Q->rear = Q->front->next;
        free(Q->front);
        Q->front = Q->rear;
    }
    return OK;
}

int main()
{
    int i;
    LinkQueue Q;
    ElemType e;
    
    //初始化
    InitLinkQueue(&Q);
    printf("初始化完成！\n");

    //入栈
    printf("请输入五个数字入队：");
    for (i = 0; i < 5; i++)
    {
        scanf("%d", &e);
        EnLinkQueue(&Q, e);
    }

    printf("依次出队为：");
    for (i = 0; i < 5; i++)
    {
        DeLinkQueue(&Q, &e);
        printf("%d ", e);
    }

    printf("\n程序使命完成，销毁链队完成！");
    DestroyLinkQueue(&Q);
    return 0;
}

---

写在最后

这一部分学完之后，刷一点题是必不可少的，推荐几道比较适用现阶段的题目

622. 设计循环队列 - 力扣（LeetCode）——中等

225. 用队列实现栈 - 力扣（LeetCode）——简单

232. 用栈实现队列 - 力扣（LeetCode）——简单

👍🏻 点赞，你的认可是我创作的动力！
⭐ 收藏，你的青睐是我努力的方向！
✏️ 评论，你的意见是我进步的财富！