队列（学习笔记）

最新推荐文章于 2024-07-07 15:59:55 发布
最新推荐文章于 2024-07-07 15:59:55 发布
阅读量506 收藏 1
点赞数
文章标签： 学习 数据结构 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43986343/article/details/126252294
版权
本文详细介绍了数据结构中的队列，包括顺序存储的非循环队列和循环队列，以及链式存储的队列实现。通过实例代码展示了队列的基本操作，如入队、出队、获取队头元素等，并解释了循环队列解决顺序队列"假溢出"问题的方法。此外，还探讨了链式存储队列的构造，包括带头结点和不带头结点的实现方式。
摘要由CSDN通过智能技术生成

写在前面的一些话：这只是个人学习王道数据结构的代码笔记，仅供参考，如果有错误请友好的指出，谢谢！！！

文章目录

队列是一种操作受限的线性表，只允许在一端进行插入，而在表的另一端进行删除。其特性是先进先出（FIFO）。

队列的顺序实现

非循环队列

定义一个队列：

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

初始化一个队列：

void InitQueue(SqQueue Q){
    //初始化时，对头、队尾指针都指向0
    Q.rear=Q.front=0;
}

队列（顺序存储）判空：

bool QueueEmpty(SqQueue Q){
    if(Q.front==Q.rear)       //队空条件
        return true;
    else
        return false;
}

入队：

bool EnQueue(SqQueue Q,int x){
    if(Q.rear==MaxSize)       //队满报错
        return false;
    Q.data[Q.rear]=x;         //将x插入队尾
    Q.rear++;                 //队尾指针后移
    return true;
}

出队：

bool DeQueue(SqQueue &Q,int &x){
    if(Q.rear==Q.front)       //队空报错
        return false;
    x=Q.data[Q.front];        //取出队头元素
    Q.front++;                //对头指针加1
    return true;
}

读对头元素：

bool GetHead(SqQueue Q,int &x){
    if(Q.rear==Q.front)       //队空报错
        return false;
    x=Q.data[Q.front];        //取队头元素
    return true;
}

完整实验代码：

#include <iostream>
using namespace std;
#define MaxSize 10            //定义队列中元素的最大个数
typedef struct{
    int data[MaxSize];        //用静态数组存放队列元素
    int front,rear;           //队头指针和队尾指针
}SqQueue;
void InitQueue(SqQueue Q){
    //初始化时，对头、队尾指针都指向0
    Q.rear=Q.front=0;
}
bool QueueEmpty(SqQueue Q){
    if(Q.front==Q.rear)       //队空条件
        return true;
    else
        return false;
}
bool EnQueue(SqQueue &Q,int x){
    if(Q.rear==MaxSize)       //队满报错
        return false;
    Q.data[Q.rear]=x;         //将x插入队尾
    Q.rear++;                 //队尾指针后移
    return true;
}
bool DeQueue(SqQueue &Q,int &x){
    if(Q.rear==Q.front)       //队空报错
        return false;
    x=Q.data[Q.front];        //取出队头元素
    Q.front++;                //对头指针加1
    return true;
}
bool GetHead(SqQueue Q,int &x){
    if(Q.rear==Q.front)       //队空报错
        return false;
    x=Q.data[Q.front];        //取队头元素
    return true;
}
void testQueue(){
    SqQueue Q;                //声明一个队列
    InitQueue(Q);             //初始化一个队列
    cout<<(QueueEmpty(Q)?"队列是空的":"队列非空")<<endl;//判断队列是否为空
    int x=1;
    while(Q.rear!=MaxSize){    //循环入队元素1-10
        EnQueue(Q,x);
        x++;
    }
    cout<<(QueueEmpty(Q)?"队列是空的":"队列非空")<<endl;
    GetHead(Q,x);           //取队头元素
    cout<<"当前对头元素是"<<x<<endl;
    cout<<"队内元素依次出队"<<endl;
    while(!QueueEmpty(Q)){
        DeQueue(Q,x);   //循环出队
        cout<<x<<endl;
    }
    cout<<(QueueEmpty(Q)?"队列是空的":"队列非空")<<endl;//此时队列为空
    cout<<(EnQueue(Q,10)?"入队成功!":"入队失败！");//但是入队失败
}
int main(){
    testQueue();
    return 0;
}

运行结果：
在这里插入图片描述

结果分析：可以看到，在队列容量为10的情况下，经历了10次入队，10次出队之后，队列本该为空，但是却入队失败，这种情况就是“假溢出”，为了解决顺序存储的队列的“假溢出”，引出下面循环队列。

循环队列

循环队列，即把存储队列元素的表从逻辑上视为一个环。

牺牲一个存储单元来区分队空和队满
判断队满：Q.rear+1)%MaxSize==Q.front
队头指针加1：Q.front=(Q.front+1)%MaxSize
队尾指针加1：Q.rear=(Q.rear+1)%MaxSize
队列长度：(Q.rear-Q.front+MaxSize)%MaxSize

与非循环队列不同的是：
入队：

bool EnQueue(SqQueue &Q,int x){
    if((Q.rear+1)%MaxSize==Q.front)       //队满报错
        return false;
    Q.data[Q.rear]=x;         //将x插入队尾
    Q.rear=(Q.rear+1)%MaxSize;//队尾元素+1取模                 //队尾指针后移
    return true;
}

出队：

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

获取队列长度：

void GetLength(SqQueue Q,int &l){
    l=(Q.rear-Q.front+MaxSize)%MaxSize;
}

完整实验代码：

#include <iostream>
using namespace std;
#define MaxSize 10            //定义队列中元素的最大个数
typedef struct{
    int data[MaxSize];        //用静态数组存放队列元素
    int front,rear;           //队头指针和队尾指针
}SqQueue;
void InitQueue(SqQueue Q){
    //初始化时，对头、队尾指针都指向0
    Q.rear=Q.front=0;
}
bool QueueEmpty(SqQueue Q){
    if(Q.front==Q.rear)       //队空条件
        return true;
    else
        return false;
}
bool EnQueue(SqQueue &Q,int x){
    if((Q.rear+1)%MaxSize==Q.front)       //队满报错
        return false;
    Q.data[Q.rear]=x;         //将x插入队尾
    Q.rear=(Q.rear+1)%MaxSize;//队尾元素+1取模                 //队尾指针后移
    return true;
}
bool DeQueue(SqQueue &Q,int &x){
    if(QueueEmpty(Q))       //队空报错
        return false;
    x=Q.data[Q.front];        //取出队头元素
    Q.front=(Q.front+1)%MaxSize;//队头指针加1取模
    return true;
}
bool GetHead(SqQueue Q,int &x){
    if(Q.rear==Q.front)       //队空报错
        return false;
    x=Q.data[Q.front];        //取队头元素
    return true;
}
void GetLength(SqQueue Q,int &l){
    l=(Q.rear-Q.front+MaxSize)%MaxSize;
}
void testQueue(){
    SqQueue Q;                //声明一个队列
    InitQueue(Q);             //初始化一个队列
    cout<<(QueueEmpty(Q)?"队列是空的":"队列非空")<<endl;//判断队列是否为空
    int x=1;
    while((Q.rear+1)%MaxSize!=Q.front){    //循环入队元素1-10
        EnQueue(Q,x);
        x++;
    }
    int l=0;
    GetLength(Q,l);
    cout<<"队列长度是"<<l<<endl;
    cout<<(QueueEmpty(Q)?"队列是空的":"队列非空")<<endl;
    GetHead(Q,x);           //取队头元素
    cout<<"当前对头元素是"<<x<<endl;
    cout<<"队内元素依次出队"<<endl;
    while(!QueueEmpty(Q)){
        DeQueue(Q,x);   //循环出队
        cout<<x<<endl;
    }
    GetLength(Q,l);
    cout<<"队列长度是"<<l<<endl;
    cout<<(QueueEmpty(Q)?"队列是空的":"队列非空")<<endl;//此时队列为空
    cout<<(EnQueue(Q,10)?"入队成功!":"入队失败！")<<endl;//但是入队失败
    GetLength(Q,l);
    cout<<"队列长度是"<<l<<endl;
}
int main(){
    testQueue();
    return 0;
}

运行结果：
在这里插入图片描述

队列的链式实现

队列的链式存储可以描述为：

typedef struct LinkNode{//链式队列结点
    int data;
    struct LinkNode * Next;
}LinkNode;
typedef struct{        //链式队列
    LinkNode *front,*rear;//链式队列的队头和队尾指针
}LinkQueue;

初始化（带头结点）：

void InitQueue(LinkQueue &Q){
    Q.front=Q.rear=(LinkNode *)malloc(sizeof(LinkNode));//建立头结点
    Q.rear->next=NULL;//初始为空
}

判空：

bool IsEmpty(LinkQueue Q){
    //判断队列是否为空
    if(Q.front==Q.rear)
        return true;
    else
        return false;
}

入队（带头结点）：

void EnQueue(LinkQueue &Q,int x){
    LinkNode *s=(LinkNode*) malloc(sizeof(LinkNode));
    s->data=x;
    s->next=NULL;
    Q.rear->next=s;         //新节点插入到rear之后
    Q.rear=s;               //修改表尾指针
}

出队（带头结点）：

bool DeQueue(LinkQueue &Q,int &x){
    if(IsEmpty(Q))          //队列为空
        return false;
    LinkNode *p=Q.front->next;
    x=p->data;              //用x变量返回队头元素
    Q.front->next=p->next;  //修改头结点的next指针
    if(Q.rear==p)           //如果是最后一个元素出队
        Q.rear=Q.front;     //修改rear指针
    free(p);        //释放结点空间
    return true;
}

获取队头元素：

bool GetHead(LinkQueue Q,int &x){
    if(IsEmpty(Q))
        return false;       //队列为空
    x=Q.front->next->data; 
    return true;
}

完整的实验代码（带头结点）：

#include <iostream>
using namespace std;
typedef struct LinkNode{//链式队列结点
    int data;
    struct LinkNode * next;
}LinkNode;
typedef struct{        //链式队列
    LinkNode *front,*rear;//链式队列的队头和队尾指针
}LinkQueue;
void InitQueue(LinkQueue &Q){
    Q.front=Q.rear=(LinkNode *)malloc(sizeof(LinkNode));//建立头结点
    Q.rear->next=NULL;//初始为空
}
bool IsEmpty(LinkQueue Q){
    //判断队列是否为空
    if(Q.front==Q.rear)
        return true;
    else
        return false;
}
void EnQueue(LinkQueue &Q,int x){
    LinkNode *s=(LinkNode*) malloc(sizeof(LinkNode));
    s->data=x;
    s->next=NULL;
    Q.rear->next=s;         //新节点插入到rear之后
    Q.rear=s;               //修改表尾指针
}
bool DeQueue(LinkQueue &Q,int &x){
    if(IsEmpty(Q))          //队列为空
        return false;
    LinkNode *p=Q.front->next;
    x=p->data;              //用x变量返回队头元素
    Q.front->next=p->next;  //修改头结点的next指针
    if(Q.rear==p)           //如果是最后一个元素出队
        Q.rear=Q.front;     //修改rear指针
    free(p);        //释放结点空间
    return true;
}
bool GetHead(LinkQueue Q,int &x){
    if(IsEmpty(Q))
        return false;       //队列为空
    x=Q.front->next->data;
    return true;
}

void test(){
    LinkQueue Q;            //声明一个队列
    InitQueue(Q);        //初始化一个队列
    cout<<(IsEmpty(Q)?"队列为空！":"队列非空！")<<endl;
    cout<<"依次入队1，2，3，4"<<endl;
    EnQueue(Q,1);
    EnQueue(Q,2);
    EnQueue(Q,3);
    EnQueue(Q,4);
    cout<<(IsEmpty(Q)?"队列为空！":"队列非空！")<<endl;
    int x;
    GetHead(Q,x);       //获取队头元素
    cout<<"此时队头元素是："<<x<<endl;
    cout<<"队列内元素依次出队："<<endl;
    while (!IsEmpty(Q)){     //循环出队
        DeQueue(Q,x);
        cout<<x<<endl;
    }
    cout<<(IsEmpty(Q)?"队列为空！":"队列非空！")<<endl;
}
int main(){
    test();
    return 0;
}

运行结果：
在这里插入图片描述

结果分析：不难看出，队列是一种先进先出的线性表

不带头结点的链式存储的队列，实验代码如下：

#include <iostream>
using namespace std;
typedef struct LinkNode{//链式队列结点
    int data;
    struct LinkNode * next;
}LinkNode;
typedef struct{        //链式队列
    LinkNode *front,*rear;//链式队列的队头和队尾指针
}LinkQueue;
void InitQueue(LinkQueue &Q){
    //初始化时front，rear都指向null
    Q.front=Q.rear=NULL;
}
bool IsEmpty(LinkQueue Q){
    //判断队列是否为空
    if(Q.front==NULL)
        return true;
    else
        return false;
}
void EnQueue(LinkQueue &Q,int x){
    LinkNode *s=(LinkNode*) malloc(sizeof(LinkNode));
    s->data=x;
    s->next=NULL;
    if(IsEmpty(Q)){         //在队列中插入第一个元素
        Q.rear=Q.front=s;
    }
    else{Q.rear->next=s;    //新节点插入到rear之后
    Q.rear=s;               //修改rear指针
    }

}
bool DeQueue(LinkQueue &Q,int &x){
    if(IsEmpty(Q))          //队列为空
        return false;
    LinkNode *p=Q.front;
    x=p->data;              //用x变量返回队头元素
    Q.front=p->next;  //修改头结点的next指针
    if(Q.rear==p)           //如果是最后一个元素出队
        Q.rear=Q.front=NULL;     //修改rear指针
    free(p);        //释放结点空间
    return true;
}
bool GetHead(LinkQueue Q,int &x){
    if(IsEmpty(Q))
        return false;       //队列为空
    x=Q.front->data;
    return true;
}

void test(){
    LinkQueue Q;            //声明一个队列
    InitQueue(Q);        //初始化一个队列
    cout<<(IsEmpty(Q)?"队列为空！":"队列非空！")<<endl;
    cout<<"依次入队1，2，3，4"<<endl;
    EnQueue(Q,1);
    EnQueue(Q,2);
    EnQueue(Q,3);
    EnQueue(Q,4);
    cout<<(IsEmpty(Q)?"队列为空！":"队列非空！")<<endl;
    int x;
    GetHead(Q,x);       //获取队头元素
    cout<<"此时队头元素是："<<x<<endl;
    cout<<"队列内元素依次出队："<<endl;
    while (!IsEmpty(Q)){     //循环出队
        DeQueue(Q,x);
        cout<<x<<endl;
    }
    cout<<(IsEmpty(Q)?"队列为空！":"队列非空！")<<endl;
}
int main(){
    test();
    return 0;
}

实验结果：
在这里插入图片描述

乔里
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构---队列笔记
weixin_44501322的博客
10-29 224
关于数据结构队列的记录
消息队列activemq学习笔记
02-04
### 消息队列Activemq学习笔记 #### MQ入门概述 消息队列（Message Queue，简称MQ）是一种用于在应用程序之间传递数据的机制。它允许应用之间通过发送消息进行通信，而无需直接调用对方。 ##### 前言：MQ=消息...
队列学习笔记
风起
03-03 693
队列和栈都是一种运算受限的线性表。只允许在表的一端进行插入，而在另一端进行删除。允许删除的叫做队首（front），允许插入的叫做队尾（rear）。即先进先出原则，如同排队取票。 1. 非循环顺序队列 队列的顺序存储结构称为顺序队列。和顺序表一样，顺序队列，顺序队列也需要用一个数组存放当前队列中的元素。由于队头和队尾都是变化的，所以需要设置两个指针，分别指示当前队头元素和队尾元素在数组中的位置。...
数据结构之“队列”（全方位认识）
最新发布
2302_80867815的博客
07-07 1158
上期博客介绍了” 栈 “这个数据结构，他具有先进后出的特点。本期介绍“ 队列 ”这个数据结构，他具有先进先出的特点。目录前言一、队列1.1队列的概念及结构1.2队列的实现1.2.1队列结构体定义1.2.2初始化和销毁1.2.3队尾插入和队头删除1.2.3.1队尾插入1.2.3.2队头删除1.2.4获取队头与队尾数据1.2.5返回队列里面的元素个数1.2.6队列判空1.3测试代码1.4代码展示头文件实现功能文件.c总结下期预告通过栈和队列互相实现对方的功能。
队列简单的笔记
做一个有信仰de人的博客
04-18 187
1.线性结构 1)线性结构作为最常用的数据结构，其特点是数据元素之间存在一对一的线性关系 2)线性结构有两种不同的存储结构，即顺序存储结构（数组）和链式存储结构（链表）。顺序存储的线性表称为顺序表，顺序表中的存储元素是连续的 3)链式存储的线性表称为链表，链表中的存储元素不一定是连续的，元素节点中存放数据元素以及相邻元素的地址信息 4)线性结构常见的有：数组、队列、链表和栈，后面我们会详细讲解...
kafka消息队列学习笔记
07-02
kafka消息队列学习笔记，kafka消息队列学习笔记，kafka消息队列学习笔记，kafka消息队列学习笔记，kafka消息队列学习笔记，kafka消息队列学习笔记，kafka消息队列学习笔记，kafka消息队列学习笔记，kafka消息队列...
Redis全套学习笔记
05-25
- **列表(List)**：双端队列，允许在两端插入和删除元素，支持范围查询，可用于消息队列。 - **集合(Set)**：不允许重复元素的集合，支持添加、删除、成员检测及集合运算（交集、并集、差集）。 - **哈希(Hash)**...
java后端学习笔记
08-21
本篇文章将深入探讨“java后端学习笔记”中的关键知识点，包括消息队列（Message Queuing）服务如ActiveMQ和RabbitMQ、工作流引擎Activity、容器化技术Docker、分布式服务框架Dubbo、网络库Netty、RPC（Remote ...
队列（笔记）
Ztt19990421的博客
03-29 84
重点:循环队列无论使用数组实现还是链表实现，都要多开一个空间，也就意味着要是一个存k个数据的循环队列，要开k+ 1个空间，否则无法实现判空和判满。①入数据，往不为空的队列入，保持另一个队列为空；②出数据的时候，依次出队头的数据，转移另一个队列保存。pop栈里没有数据，要从push栈里导过来，popST中的数据就符合先进先出了。队列:只允许在一端进行插入数据操作， 在另一端进行删除 数据操作的特殊线性表,队列具有先进先出FIFO(First In First Out)出队列:进行删除操作的一端称为队头。
队列_笔记
My classmates
08-23 127
与栈类似但规则不一样，栈是先进后出只有一个口，队列是两个口规则先进先出一个口只能进，一个口只能出 .h #define MAX_SIZE 1024 //顺序队列结构体 typedef struct SEQQUEUE { void *data[MAX_SIZE]; int size; }SeqQueue; class Queue { public: Queu...
队列笔记
hqwhardwork的专栏
08-09 613
队列的用途： 先来先服务的原则： 订票系统，操作系统的作业调度，消息队列。 顺序队列 结构体中的数组用来存储入队的元素。 typedef struct { DATATYPE items[QUEUESIZE]; int front,rear; }SqQueue; 顺序队列的溢出问题。 1：队列满时还要进行入队操作，rear会超出数组的下标。上溢。 2：队列空时还要出队
【数据结构】队列 笔记整理
weixin_51630192的博客
07-26 330
【数据结构】 队列部分笔记整理，包含循环队列、链式队列等知识。参考自《大话数据结构》，为本人整理的一些笔记，学习内容。
消息队列笔记
宏浩叔叔的博客
11-27 1030
常见消息队列：ActiveMQ、RabbitMQ、Kafka，阿里巴巴自主开发的Notify、MetaQ、RocketMQ等。 常用于解决：业务解耦/最终一致性/广播/错峰流控 如果下游有很多业务方关系你的系统发出的通知的时候 ，果断的使用消息队列吧 业界的一些为最终一致性而生的消息队列如notify（阿里）、QMQ(去哪儿)，设计初衷是为了交易系统中的高可靠通知。一种实现方案是通过补偿机制， 比如
栈、队列、优先队列笔记
西二旗的小飞飞
08-01 378
20. Valid Parentheses 150. Evaluate Reverse Polish Notation 71. Simplify Path 144. Binary Tree Preorder Traversal 94. Binary Tree Inorder Traversal 145. Binary Tree Postorder Traversal 341. Flatt
队列——学习笔记
星星leslie的博客
09-07 149
队列 封装结构体（数组） #define MAXSIZE 1000 typedef struct { int elem[MAXSIZE]; int rear, front; }SeQueue; 初始化 SeQueue *InitQueue() { SeQueue *s = (SeQueue *)malloc(sizeof(SeQueue)); s->front = s->re...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值