【数据结构--队列】

已于 2022-10-06 19:35:11 修改
阅读量523 收藏 1
点赞数
分类专栏： 数据结构 文章标签： 数据结构 链表
于 2022-05-17 22:37:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_61719813/article/details/124830176
版权

文章目录

队列

一、队列的定义

​ 队列和栈一样是一种操作受限的线性表，其特殊之处在于只允许在表的头部（即队头–front）进行删除，而在表的尾部（即队尾–rear）进行插入操作，所以只有最早进入队列的元素才能最先从队列中删除，故队列又称为先进先出（FIFO—first in first out）线性表。队列的结构体如下图所示：
在这里插入图片描述

二、链队

​ 链队是指采用链式存储结构来实现的队列，通常链队用单链表来表示，如下图所示，一个链队需要两个分别指示队头和队尾的指针才能确定。

链队的结构图

在这里插入图片描述

代码描述：

typedef int ElemType;

typedef struct QNode
{
    ElemType data;
    struct QNode* next;
} QNode, *QNodePtr;

typedef struct LinkQueue
{
    QNodePtr front,rear;
} LinkQueue, *LinkQueuePtr;

三、链队的基本操作

链队的初始化

算法步骤：

  • 生成新的结点作为头结点，队头（front）和队尾（rear）指针指向此结点
  • 头结点的指针域为空

代码如下：

/* 初始化队列 */
LinkQueuePtr InitQueue()
{
    LinkQueuePtr resultPtr = (LinkQueuePtr)malloc(sizeof(LinkQueue));
    QNodePtr header = (QNodePtr)malloc(sizeof(QNode));
    header->next = NULL;
    resultPtr->front = header;
    resultPtr->rear = header;
    return resultPtr;
}

入队

​ 由于链队是基于链表的队列，其结点为动态创建和动态删除，故不存在溢出等问题。

算法步骤：

  • 为入队元素分配结点空间，用指针tempNodePtr指向
  • 将新结点的数据域改为tempElem，指针域改为NULL
  • 将新结点插入到队尾
  • 修改队尾指针(rear)为tempNodePtr

如下图所示：
在这里插入图片描述

代码如下：

/* 入队操作 */
void EnQueue(LinkQueuePtr tempQueuePtr, ElemType tempElem)
{
    QNodePtr tempNodePtr = (QNodePtr)malloc(sizeof(QNode));
    tempNodePtr->data = tempElem;
    tempNodePtr->next = NULL;
    tempQueuePtr->rear->next = tempNodePtr;
    tempQueuePtr->rear = tempNodePtr;
}

出队

​ 链队在出队前需要判断队列是否为空，链队在出队后需要释放队头元素的所占空间

算法步骤：

  • 判断队列是否为空，若为空则返回-1
  • 用tempNodePtr临时保存队头元素的空间，以备释放
  • 用临时变量DeValue保存队头元素的数据域，以用于返回
  • 修改头结点的指针域，指向下一个结点
  • 判断出队元素是否为最后一个元素，若是，则将队尾指针指向头结点
  • 释放原头元素的空间并将tempNodePtr指针置为NULL

如下图所示：

在这里插入图片描述

代码如下：

/* 出队操作 */
ElemType DeQueue(LinkQueuePtr tempQueuePtr)
{
    ElemType DeValue;
    QNodePtr tempNodePtr;
    if(tempQueuePtr->front == tempQueuePtr->rear)
    {
        printf("队列为空！\n");
        return -1;
    }
    tempNodePtr = tempQueuePtr->front->next;
    DeValue = tempNodePtr->data;
    tempQueuePtr->front->next = tempNodePtr->next;
    if(tempQueuePtr->rear == tempNodePtr)
    {
        tempQueuePtr->rear = tempQueuePtr->front;
    }
    free(tempNodePtr);
    tempNodePtr = NULL;
    return DeValue;
}

打印队列

/* 打印队列 */
void OutPutQueue(LinkQueuePtr tempQueuePtr)
{
    QNodePtr tempNodePtr = tempQueuePtr->front->next;
    while (tempNodePtr)
    {
        printf("% d",tempNodePtr->data);
        tempNodePtr = tempNodePtr->next;
    }
    printf("\n");
    return ;
}

取队头元素

/* 取队头元素 */
ElemType GetHead(LinkQueuePtr tempQueuePtr)
{
    if (tempQueuePtr->front != tempQueuePtr->rear)
    {
        return tempQueuePtr->front->next->data;
    }
    printf("队列为空！\n");
    return -1;   
}

清空队列

/* 清空队列 */
void ClearQueue(LinkQueuePtr tempQueuePtr)
{
    if(tempQueuePtr->front == tempQueuePtr->rear)
    {
        printf("队列为空！\n");
        return ;
    }
    while(tempQueuePtr->front->next)
    {
        DeQueue(tempQueuePtr);
    }
}

返回队列长度

/* 返回队列长度 */
int QueueLength(LinkQueuePtr tempQueuePtr)
{
    int length = 0;
    if(tempQueuePtr->front == tempQueuePtr->rear)
    {
        printf("队列为空！\n");
        return length;
    }
    QNodePtr tempNodePtr = tempQueuePtr->front->next;
    while (tempNodePtr)
    {
        length++;
        tempNodePtr = tempNodePtr->next;
    }
    return length;
}

完整代码

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

typedef int ElemType;

typedef struct QNode
{
    ElemType data;
    struct QNode* next;
} QNode, *QNodePtr;

typedef struct LinkQueue
{
    QNodePtr front,rear;
} LinkQueue, *LinkQueuePtr;

/* 初始化队列 */
LinkQueuePtr InitQueue()
{
    LinkQueuePtr resultPtr = (LinkQueuePtr)malloc(sizeof(LinkQueue));
    QNodePtr header = (QNodePtr)malloc(sizeof(QNode));
    header->next = NULL;
    resultPtr->front = header;
    resultPtr->rear = header;
    return resultPtr;
}

/* 打印队列 */
void OutPutQueue(LinkQueuePtr tempQueuePtr)
{
    QNodePtr tempNodePtr = tempQueuePtr->front->next;
    while (tempNodePtr)
    {
        printf("% d",tempNodePtr->data);
        tempNodePtr = tempNodePtr->next;
    }
    printf("\n");
    return ;
}

/* 入队操作 */
void EnQueue(LinkQueuePtr tempQueuePtr, ElemType tempElem)
{
    QNodePtr tempNodePtr = (QNodePtr)malloc(sizeof(QNode));
    tempNodePtr->data = tempElem;
    tempNodePtr->next = NULL;
    tempQueuePtr->rear->next = tempNodePtr;
    tempQueuePtr->rear = tempNodePtr;
}

/* 出队操作 */
ElemType DeQueue(LinkQueuePtr tempQueuePtr)
{
    ElemType DeValue;
    QNodePtr tempNodePtr;
    if(tempQueuePtr->front == tempQueuePtr->rear)
    {
        printf("队列为空！\n");
        return -1;
    }
    tempNodePtr = tempQueuePtr->front->next;
    DeValue = tempNodePtr->data;
    tempQueuePtr->front->next = tempNodePtr->next;
    if(tempQueuePtr->rear == tempNodePtr)
    {
        tempQueuePtr->rear = tempQueuePtr->front;
    }
    free(tempNodePtr);
    tempNodePtr = NULL;
    return DeValue;
}

/* 取队头元素 */
ElemType GetHead(LinkQueuePtr tempQueuePtr)
{
    if (tempQueuePtr->front != tempQueuePtr->rear)
    {
        return tempQueuePtr->front->next->data;
    }
    printf("队列为空！\n");
    return -1;   
}

/* 清空队列 */
void ClearQueue(LinkQueuePtr tempQueuePtr)
{
    if(tempQueuePtr->front == tempQueuePtr->rear)
    {
        printf("队列为空！\n");
        return ;
    }
    while(tempQueuePtr->front->next)
    {
        DeQueue(tempQueuePtr);
    }
}

/* 返回队列长度 */
int QueueLength(LinkQueuePtr tempQueuePtr)
{
    int length = 0;
    if(tempQueuePtr->front == tempQueuePtr->rear)
    {
        printf("队列为空！\n");
        return length;
    }
    QNodePtr tempNodePtr = tempQueuePtr->front->next;
    while (tempNodePtr)
    {
        length++;
        tempNodePtr = tempNodePtr->next;
    }
    return length;
}

/* 测试 */
void test()
{
    LinkQueuePtr tempQueuePtr = InitQueue();
    printf("--------入队测试--------\n");
    EnQueue(tempQueuePtr,5);
    EnQueue(tempQueuePtr,2);
    EnQueue(tempQueuePtr,0);
    OutPutQueue(tempQueuePtr);
    printf("--------队列长度--------\n");
    printf("队列长度为%d\n",QueueLength(tempQueuePtr));
    printf("--------出队测试--------\n");
    printf("出队的元素是%d.\n",DeQueue(tempQueuePtr));
    printf("出队的元素是%d.\n",DeQueue(tempQueuePtr));
    printf("出队的元素是%d.\n",DeQueue(tempQueuePtr));
    printf("出队的元素是%d.\n",DeQueue(tempQueuePtr));
    printf("--------入队测试--------\n");
    EnQueue(tempQueuePtr,5);
    EnQueue(tempQueuePtr,2);
    EnQueue(tempQueuePtr,0);
    OutPutQueue(tempQueuePtr);
    printf("--------取队头元素--------\n");
    printf("队头元素是%d.\n",GetHead(tempQueuePtr));
    printf("--------清空队列--------\n");
    ClearQueue(tempQueuePtr);
    OutPutQueue(tempQueuePtr);
    printf("--------队列长度--------\n");
    printf("队列长度为%d\n",QueueLength(tempQueuePtr));
    printf("--------取队头元素--------\n");
    printf("队头元素是%d.\n",GetHead(tempQueuePtr));
}

int main()
{
    test();
}

运行测试

--------入队测试--------
 5 2 0
--------队列长度--------
队列长度为3
--------出队测试--------
出队的元素是5.
出队的元素是2.
出队的元素是0.
队列为空！
出队的元素是-1.
--------入队测试--------
 5 2 0
--------取队头元素--------
队头元素是5.
--------清空队列--------

--------队列长度--------
队列为空！
队列长度为0
--------取队头元素--------
队列为空！
队头元素是-1.

四、循环队列

循环队列就是将队列存储空间的最后一个位置绕到第一个位置，形成逻辑上的环状空间，供队列循环使用。 循环队列可以更简单防止伪溢出的发生，但队列大小是固定的。

循环队列结构图

在这里插入图片描述代码描述：

typedef int ElemType;

typedef struct CircleQueue
{
    ElemType data[MAXQSIZE];
    int front;
    int tail;
} CircleQueue,*CircleQueuePtr;

五、循环队列的基本操作

循环队列的初始化
算法步骤：

  • 为队列分配一个最大容量为MAXQSIZE的数组空间
  • 头指针（front）和尾指针（tail）置为零，表示队列为空，返回resultPtr

代码如下：

/* 初始化队列 */
CircleQueuePtr InitQueue()
{
    CircleQueuePtr resultPtr = (CircleQueuePtr)malloc(sizeof(CircleQueue));
    resultPtr->front = 0;
    resultPtr->tail = 0;
    return resultPtr;
}

入队
算法步骤：

  • 判断队列是否满，若满返回
  • 将新元素插入队尾
  • 队尾指针加1

注意：
当队列为空时，有front = tail，而当所有队列空间全占满时，也有front=tail。为了区别这两种情况，规定循环队列最多只能有MAXQSIZE - 1个队列元素，当循环队列中只剩下一个空存储单元时，队列就已经满了。因此，队列判空的条件是front = rear，队列判满的条件是front =（rear + 1) % MAXQSIZE。

代码如下：

/* 入队操作 */
void EnQueue(CircleQueuePtr tempQueuePtr, ElemType tempValue)
{
    if((tempQueuePtr->tail+1) % MAXQSIZE == tempQueuePtr->front)
    {
        printf("队列已满！\n");
        return ;
    }
    tempQueuePtr->data[tempQueuePtr->tail % MAXQSIZE] = tempValue;
    tempQueuePtr->tail++;
}

出队操作
算法步骤：

  • 判断队列是否为空，为空则返回-1
  • 保存队头元素
  • 队头指针加1
/* 出队操作 */
ElemType DeQueue(CircleQueuePtr tempQueuePtr)
{
    ElemType DeValue;
    if (tempQueuePtr->front == tempQueuePtr->tail)
    {
        printf("队列为空！\n");
        return -1;
    }
    DeValue = tempQueuePtr->data[tempQueuePtr->front % MAXQSIZE];
    tempQueuePtr->front++;
    return DeValue;
}

求队列长度
对于非循环队列，尾指针和和头指针之差便是队列长度，但对于循环队列而言，差值可能为负值，因此需要将差值加上MAXQSIZE，然后对MAXQSIZE取余。
代码如下：

int QueueLength(CircleQueuePtr tempQueuePtr)
{
	return (tempQueuePtr->tail - tempQueuePtr->front + MAXQSIZE) % MAXQSIZE;
}

取循环队列的队头元素
代码如下：

/* 取队头元素 */
ElemType GetHead(CircleQueuePtr tempQueuePtr)
{
    if(tempQueuePtr->front == tempQueuePtr->tail)
    {
        printf("队列为空！\n");
        return -1;
    }
    return tempQueuePtr->data[tempQueuePtr->front];
}

完整代码

#include <stdio.h>
#include <malloc.h>
#define MAXQSIZE 5

typedef int ElemType;

typedef struct CircleQueue
{
    ElemType data[MAXQSIZE];
    int front;
    int tail;
} CircleQueue,*CircleQueuePtr;

/* 初始化队列 */
CircleQueuePtr InitQueue()
{
    CircleQueuePtr resultPtr = (CircleQueuePtr)malloc(sizeof(CircleQueue));
    resultPtr->front = 0;
    resultPtr->tail = 0;
    return resultPtr;
}

/* 入队操作 */
void EnQueue(CircleQueuePtr tempQueuePtr, ElemType tempValue)
{
    if((tempQueuePtr->tail+1) % MAXQSIZE == tempQueuePtr->front)
    {
        printf("队列已满！\n");
        return ;
    }
    tempQueuePtr->data[tempQueuePtr->tail % MAXQSIZE] = tempValue;
    tempQueuePtr->tail++;
}

/* 返回队列长度 */
int QueueLength(CircleQueuePtr tempQueuePtr)
{
	return (tempQueuePtr->tail - tempQueuePtr->front + MAXQSIZE) % MAXQSIZE;
}

/* 出队操作 */
ElemType DeQueue(CircleQueuePtr tempQueuePtr)
{
    ElemType DeValue;
    if (tempQueuePtr->front == tempQueuePtr->tail)
    {
        printf("队列为空！\n");
        return -1;
    }
    DeValue = tempQueuePtr->data[tempQueuePtr->front % MAXQSIZE];
    tempQueuePtr->front++;
    return DeValue;
}

/* 输出队列 */
void QueueTraverse(CircleQueuePtr tempQueuePtr)
{
    if (tempQueuePtr->front == tempQueuePtr->tail)
    {
        printf("队列为空！\n");
        return ;
    }
    printf("队列中的元素为：");
    for(int i = tempQueuePtr->front; i < tempQueuePtr->tail; ++i)
    {
        printf("% d",tempQueuePtr->data[i % MAXQSIZE]);
    }
    printf("\n");
}

/* 取队头元素 */
ElemType GetHead(CircleQueuePtr tempQueuePtr)
{
    if(tempQueuePtr->front == tempQueuePtr->tail)
    {
        printf("队列为空！\n");
        return -1;
    }
    return tempQueuePtr->data[tempQueuePtr->front];
}

/* 测试 */
void test()
{
    CircleQueuePtr tempQueuePtr = InitQueue();
    printf("--------入队操作--------\n");
    for(int i = 1; i < 5; ++i)
    {
        EnQueue(tempQueuePtr,i);
    }
    QueueTraverse(tempQueuePtr);
    printf("当前队列长度是%d\n",QueueLength(tempQueuePtr));
    printf("--------出队操作--------\n");
    for(int i = 0; i < 6; ++i)
    {
        printf("出队元素是%d\n",DeQueue(tempQueuePtr));
    }
    printf("当前队列长度是%d\n",QueueLength(tempQueuePtr));
    printf("--------入队操作--------\n");
    for (int i = 5; i < 9; ++i)
    {
        EnQueue(tempQueuePtr,i);
    }
    QueueTraverse(tempQueuePtr);
    printf("当前队头元素是%d\n",GetHead(tempQueuePtr));
}

int main()
{
    test();
}

运行测试

--------入队操作--------
队列中的元素为： 1 2 3 4
当前队列长度是4
--------出队操作--------
出队元素是1
出队元素是2
出队元素是3
出队元素是4
队列为空！
出队元素是-1
队列为空！
出队元素是-1
当前队列长度是0
--------入队操作--------
队列中的元素为： 5 6 7 8
当前队头元素是5

六、总结

  • 队列在日常生活中使用广泛，比如排队买 XXX、医院的挂号系统等，采用的都是队列的结构。
  • 链式队列可以实现一个无限排队的无界队列，但是极有可能导致排队过多，请求被处理的时效非常长，所以针对响应时间要求高的系统，链式队列是不适用的
  • 顺序队列是有界的，当请求入队使得队列满了后，后续请求都会被拒绝，比较适合对响应时间要求高的系统。
黎子想写好代码
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构--队列--思维导图.pdf
08-29
数据结构--队列--思维导图.pdf
数据结构：什么是typedef？typedef的用法？应用举例
Molly 的博客
12-03 1964
数据结构：什么是typedef？typedef的用法？应用举例
关于数据结构（c语言）中结构体声明的typedef struct LNode, *LinkList的思考
weixin_44986275的博客
06-24 5437
在数据结构的链表，表示中 typedef struct Node * PtrToNode 和 typerdef struct List的表示说明 typedef struct Node * PtrToNode; struct Node{ elementype data; ptrToNode Next； }; typeded ptrToNode List; List L; 这段代码中 用typeder这个方式 来重命名 struct Node* 这个结构体类型，所以 ptrToNode 这个变量名就可以直接
C语言数据结构-4.队列的顺序及链式存储结构
Chunix的专栏
07-27 935
1.顺序参考代码
数据结构问题解决2.1——单链表存储结构定义详细解释，struct LNode* next解释，为啥next定义成指针类型
longbow_nice的博客
07-09 4738
单链表的存储结构定义详细解释，struct LNode* next解释，为啥next定义成指针类型
结构体与队列
u013744104的博客
10-17 1809
队列的定义为先进先出，像排队一样。 队列的形式： 顺序队列：用数组表达。链式队列，用链表表达。循环队列：用数组表达 队列的元素的结构体： //Define a node typedef struct QuequeNode { int data; struct QuequeNode* next; }QueueNode; 队列本身的数据结构：包含头尾节点以及Size. 规则为尾进头出（方便操作） // Define a Linked Queue typedef struct LinkQueue
数据结构--队列实验报告.docx
03-24
数据结构--队列实验报告
数据结构--队列.ppt
07-11
数据结构--队列.ppt该文档详细且完整，值得借鉴下载使用，欢迎下载使用，有问题可以第一时间联系作者~
数据结构-队列实验报告.docx
11-29
数据结构-队列实验报告.docx
数据结构-循环队列-C语言实现循环队列-数据结构学习
最新发布
05-27
C语言实现的数据结构中的循环队列 包含源码（.c文件），linux环境下编译生成的可执行文件，头文件，以及测试用的main.c文件 用于C语言以及数据结构的学习 循环队列的.c和.h文件实现了以下功能： 创建循环队列 入队列...
C语言实现--链队列（详解）
m0_54158068的博客
03-30 1806
C语言实现--链队列（详解） 关于“链队列”的分析等，如果存在疑惑，想要探究过程，请读者参见文章： ​​​​​​​“循环队列（详解）---＞数据结构、C++实现”（点击查看）。 之后再回到这个页面看C语言实现“循环队列”， 为提高效率在这里不再重复进行分析介绍，C++与C语言分析过程相同，两者代码实现主要区别在于“编程语法”上，读者可以对比两篇文章中的代码部分体会。 代码实现 ...
数据结构：循环队列的顺序存储结构
CSU_hhxyliang的博客
08-22 536
队列只允许在队尾插入，在队头删除 循环队列防止假溢出现象 顺序存储结构用数组实现 #include <iostream> using namespace std; #define OK 1 #define ERROR 0 #define MAXSIZE 6 typedef int ElemType; typedef int Status; /* 定义顺序存储结构的循环队列：SqQue...
数据结构——队列
m0_53846409的博客
09-28 500
1.队列的定义 ​ 队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。 队列储存的图像表示： （图片来源于网络，侵删） 2、队列的基本运算 ​ 1）初始化队列：Init_Queue(q) ，初始条件：队q 不存在。操作结果：构造了一个空队； ​ 2）入队操作： In_Queue(q,x),初始条件： 队q 存在。操作结果： 对已存在的队列q，插
数据结构_队列
weixin_43853178的博客
08-12 739
队列类似于日常生活中的排队，它也是一种特殊的线性表。队列和栈有相反的逻辑，但是却属于同类结构。
队列的顺序存储结构-顺序队列
小陈没烦恼
02-24 649
队列的定义 队列是一种先进先出的线性表，它只允许在表的一段进行插入，而在另一端进行删除。在队列中允许插入的一端叫做队尾，允许删除的一端叫做对头。 队列的基本操作 (1)队列的初始化 (2)销毁队列 (3)清空队列 (4)判空 (5)取队列长度 (6)取队头元素 (7)入队 (8)出队 定义顺序队列结构 typedef struct { int *base; //基地址用于存储队列元素 int front; //头指针 int rear; //尾指针...
typedef的使用详解
weixin_54534636的博客
05-31 6163
typedef的使用详解
数据结构队列的顺序存储
雨季的博客
11-26 699
数据结构队列的顺序存储 /*数据结构队列的顺序存储结构*/ #include #include #define MaxSize 100 typedef int ElemType; typedef struct {          ElemTypedata[MaxSize];   //存放队列的数据          intfront,rear;            /
C++ 链表、栈、队列
weixin_40535588的博客
12-05 4394
一、C++ 链表 链表实际上是线性表的链式存储结构，与数组不同的是，它是用一组任意的存储单元来存储线性表中的数据，存储单元不一定是连续的， 且链表的长度不是固定的，链表数据的这一特点使其可以非常的方便地实现节点的插入和删除操作 1.1 几种链表的介绍 1.1.1 单向链表 单向链表很容易理解，就说把指针当成一条链一样连接每一个节点，每个节点包含了一个或者多个数据。链表的存储单元不一定是连续的，长度不固定，主要用于方便实现节点的插入和删除操作。官方的话这里就不说了，作为数据结构里最基本的，感兴趣的童鞋自.
队列的顺序存储结构和链式存储结构
热门推荐
那年聪聪
05-06 1万+
队列、队列的顺序存储结构、链式存储结构
数据结构-队列的应用
07-28
回答: 队列是一种常见的数据结构，它遵循先进先出（FIFO）的原则。队列的应用非常广泛。其中一种应用是在操作系统中进行进程调度。操作系统使用队列来管理进程的执行顺序，确保每个进程按照一定的规则得到执行的机会...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

黎子想写好代码

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值