【数据结构】循环队列的顺序存储

最新推荐文章于 2023-07-11 18:55:23 发布
最新推荐文章于 2023-07-11 18:55:23 发布
阅读量651 收藏 3
点赞数 1
文章标签： 数据结构 算法 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_67689541/article/details/130002745
版权
该文章介绍了如何使用C语言实现循环队列的顺序存储结构，并详细阐述了初始化、判断队列状态（空、满）、入队、出队、获取队头元素、打印队列元素等基本操作。代码示例展示了整个过程。
摘要由CSDN通过智能技术生成

文章目录

⭐️写在前面的话⭐️

📒博客主页： 程序员好冰
🎉欢迎 【点赞👍 关注🔎 收藏⭐️ 留言📝】
📌本文由 程序员好冰 原创，CSDN 首发！
📆入站时间： 🌴2022 年 07 月 13 日🌴
✉️ 是非不入松风耳，花落花开只读书。
💭推荐书籍：📚《Java编程思想》，📚《Java 核心技术卷》
💬参考在线编程网站：🌐牛客网🌐力扣
🍭 作者水平很有限，如果发现错误，一定要及时告知作者哦！感谢感谢！🍭

循环队列的顺序存储

0、自定义声明

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

//循环队列的顺序存储
#define MAX_SIZE 5
#define OK 1
#define ERROR 0

typedef int ElemType;
typedef int Status;

typedef struct CSqQueue
{
    ElemType data[MAX_SIZE];
    /*
        队列为空，front==rear
        队列为满，(rear+1)%MAX_SIZE==front
        队列有元素，且不为空，rear指向队尾元素的下一个位置
        front可以有元素，rear不可以有元素
        因此，队列中实际拥有的元素是MAX_SIZE-1
    */
    int front;
    int rear;
}CSqQueue;

1、初始化循环队列

Status InitQueue(CSqQueue *CS)
{
    CS->front=0;
    CS->rear=0;
    printf("初始化队列成功.\n");
    return OK;
}

2、判断队列是否为空

front和rear指向同一个位置，又因为rear不存放元素，说明队列为空

Status QueueEmpty(CSqQueue CS)
{
    if(CS.front==CS.rear){
        printf("队列为空.\n");
        return OK;
    }
    printf("队列不为空.\n");
    return ERROR;
}

3、队列的长度

队列的长队分为两段:一是MAX_SIZE-front；另一是0+rear。

Status QueueLength(CSqQueue CS)
{
    if(QueueEmpty(CS)){
        printf("队列的长度为0.\n");
        return ERROR;
    }
    printf("队列的长度为%d.\n",(CS.rear-CS.front+MAX_SIZE)%MAX_SIZE);
    return OK;
}

4、清空队列

清空队列可以分为两步：

处理队列的头尾指针

将队列中每个元素置空

Status ClearQueue(CSqQueue *CS)
{
    CS->front=0;
    CS->rear=0;
    int i;
    for(i=0;i<QueueLength(*CS);i++){
        CS->data[i]='\0';
    }
    printf("队列清空成功.\n");
    return OK;
}

5、判断队列是否满

注意rear处是不存放元素的，因此需要加1

Status QueueIsFull(CSqQueue CS)
{
    if((CS.rear+1)%MAX_SIZE==CS.front){
        printf("队列满了.\n");
        return OK;
    }
    printf("队列未满了.\n");
    return ERROR;
}

6、入队

入队，CS->rear=(CS->rear+1)%MAX_SIZE;说明是以MAX_SIZE作为一个循环的。

Status EnQueue(CSqQueue *CS,ElemType e)
{
    if(QueueIsFull(*CS)){
        return ERROR;
    }
    CS->data[CS->rear]=e;
    CS->rear=(CS->rear+1)%MAX_SIZE;
    printf("元素%d入队成功.\n",e);
    return OK;
}

7、销毁队列

先清空，再释放。

Status DestroyQueue(CSqQueue *CS)
{
    ClearQueue(CS);
    free(CS);
    return OK;
}

8、获取队头元素

Status GetHead(CSqQueue CS)
{
    if(QueueEmpty(CS)){
        return ERROR;
    }
    printf("队头元素为:%d.\n",CS.data[CS.front]);
    return OK;
}

9、出队

出队，CS->front=(CS->front+1)%MAX_SIZE;

同样是以MAX_SIZE为一个轮回。

ElemType DeQueue(CSqQueue *CS)
{
    if(QueueEmpty(*CS)){
        return ERROR;
    }
    printf("队头元素%d删除成功.\n",CS->data[CS->front]);
    CS->front=(CS->front+1)%MAX_SIZE;//对MAX_SIZE取余的意思是，以MAX_SIZE作一个轮回
    return OK;
}

10、打印队列中所有元素

到达队中元素末尾的条件：(i+CS.front)==CS.rear

//队列先进先出，先打印队头元素
Status PrintfQueue(CSqQueue CS)
{
    if(QueueEmpty(CS)){
        return ERROR;
    }
    int i;
    i=CS.front;
    printf("队列为:");
    while((i+CS.front)!=CS.rear){
        printf("%d  ",CS.data[i]);
        i=(i+1)%MAX_SIZE;
    }
    return OK;
}

主函数

int main()
{
    CSqQueue CS;
    int input;
    int value;
    printf("请继续操作...\n");
    while(1){
        printf("\n==========================\n");
        printf("1、初始化循环队列.\n");
        printf("2、销毁队列.\n");
        printf("3、清空队列.\n");
        printf("4、判断队列是否为空.\n");
        printf("5、获得队头元素.\n");
        printf("6、插入队尾元素.\n");
        printf("7、删除队头元素.\n");
        printf("8、返回队列中元素个数.\n");
        printf("9、打印队列中所有元素.\n");
        printf("\n==========================\n");
        printf("请输入对应操作的序号:");
        scanf("%d",&input);
        switch(input){
        case 1:
            InitQueue(&CS);
            break;
        case 2:
            DestroyQueue(&CS);
            break;
        case 3:
            ClearQueue(&CS);
            break;
        case 4:
            QueueEmpty(CS);
            break;
        case 5:
            GetHead(CS);
            break;
            break;
        case 6:
            printf("请输入需要入队的元素:");
            scanf("%d",&value);
            EnQueue(&CS,value);
            break;
        case 7:
            DeQueue(&CS);
            break;
        case 8:
            QueueLength(CS);
            break;
        case 9:
            PrintfQueue(CS);
            break;
        case 10:
            QueueIsFull(CS);
            break;
        default:
            printf("输入的序号有误,请重新输入.\n");
            break;
        }
    }
    return 0;
}

程序源码

运行效果

image-20230406235857146 
#include <stdio.h>
#include <stdlib.h>

//循环队列的顺序存储
#define MAX_SIZE 5
#define OK 1
#define ERROR 0

typedef int ElemType;
typedef int Status;

typedef struct CSqQueue
{
    ElemType data[MAX_SIZE];
    /*
        队列为空，front==rear
        队列为满，(rear+1)%MAX_SIZE==front
        队列有元素，且不为空，rear指向队尾元素的下一个位置
        front可以有元素，rear不可以有元素
        因此，队列中实际拥有的元素是MAX_SIZE-1
    */
    int front;
    int rear;
}CSqQueue;

//函数声明
Status InitQueue(CSqQueue *CS)
{
    CS->front=0;
    CS->rear=0;
    printf("初始化队列成功.\n");
    return OK;
}

Status QueueEmpty(CSqQueue CS)
{
    if(CS.front==CS.rear){
        printf("队列为空.\n");
        return OK;
    }
    printf("队列不为空.\n");
    return ERROR;
}

Status QueueLength(CSqQueue CS)
{
    if(QueueEmpty(CS)){
        printf("队列的长度为0.\n");
        return ERROR;
    }
    printf("队列的长度为%d.\n",(CS.rear-CS.front+MAX_SIZE)%MAX_SIZE);
    return OK;
}

Status ClearQueue(CSqQueue *CS)
{
    CS->front=0;
    CS->rear=0;
    int i;
    for(i=0;i<QueueLength(*CS);i++){
        CS->data[i]='\0';
    }
    printf("队列清空成功.\n");
    return OK;
}

Status QueueIsFull(CSqQueue CS)
{
    if((CS.rear+1)%MAX_SIZE==CS.front){
        printf("队列满了.\n");
        return OK;
    }
    printf("队列未满了.\n");
    return ERROR;
}

Status EnQueue(CSqQueue *CS,ElemType e)
{
    if(QueueIsFull(*CS)){
        return ERROR;
    }
    CS->data[CS->rear]=e;
    CS->rear=(CS->rear+1)%MAX_SIZE;
    printf("元素%d入队成功.\n",e);
    return OK;
}

Status DestroyQueue(CSqQueue *CS)
{
    ClearQueue(CS);
    free(CS);
    return OK;
}

Status GetHead(CSqQueue CS)
{
    if(QueueEmpty(CS)){
        return ERROR;
    }
    printf("队头元素为:%d.\n",CS.data[CS.front]);
    return OK;
}

ElemType DeQueue(CSqQueue *CS)
{
    if(QueueEmpty(*CS)){
        return ERROR;
    }
    printf("队头元素%d删除成功.\n",CS->data[CS->front]);
    CS->front=(CS->front+1)%MAX_SIZE;//对MAX_SIZE取余的意思是，以MAX_SIZE作一个轮回
    return OK;
}

//队列先进先出，先打印队头元素
Status PrintfQueue(CSqQueue CS)
{
    if(QueueEmpty(CS)){
        return ERROR;
    }
    int i;
    i=CS.front;
    printf("队列为:");
    while((i+CS.front)!=CS.rear){
        printf("%d  ",CS.data[i]);
        i=(i+1)%MAX_SIZE;
    }
    return OK;
}

int main()
{
    CSqQueue CS;
    int input;
    int value;
    printf("请继续操作...\n");
    while(1){
        printf("\n==========================\n");
        printf("1、初始化循环队列.\n");
        printf("2、销毁队列.\n");
        printf("3、清空队列.\n");
        printf("4、判断队列是否为空.\n");
        printf("5、获得队头元素.\n");
        printf("6、插入队尾元素.\n");
        printf("7、删除队头元素.\n");
        printf("8、返回队列中元素个数.\n");
        printf("9、打印队列中所有元素.\n");
        printf("\n==========================\n");
        printf("请输入对应操作的序号:");
        scanf("%d",&input);
        switch(input){
        case 1:
            InitQueue(&CS);
            break;
        case 2:
            DestroyQueue(&CS);
            break;
        case 3:
            ClearQueue(&CS);
            break;
        case 4:
            QueueEmpty(CS);
            break;
        case 5:
            GetHead(CS);
            break;
            break;
        case 6:
            printf("请输入需要入队的元素:");
            scanf("%d",&value);
            EnQueue(&CS,value);
            break;
        case 7:
            DeQueue(&CS);
            break;
        case 8:
            QueueLength(CS);
            break;
        case 9:
            PrintfQueue(CS);
            break;
        case 10:
            QueueIsFull(CS);
            break;
        default:
            printf("输入的序号有误,请重新输入.\n");
            break;
        }
    }
    return 0;
}

🚀先看后赞，养成习惯！🚀

🚀 先看后赞，养成习惯！🚀

🎈觉得文章写得不错的老铁们，点赞评论关注走一波！谢谢啦！🎈

程序员好冰
关注
头歌数据结构循环队列及链队列的基本操作
05-18
在本文中，我们将深入探讨头歌数据结构中的两种基本数据结构——循环队列和链队列，以及它们在实现过程中的基本操作。首先，我们来理解这两种数据结构的概念。 循环队列是一种线性数据结构，它模拟了现实生活中的...
【数据结构】设计循环队列
Extreme_wei的博客
04-04 1165
设计你的循环队列实现。 循环队列是一种线性数据结构，其操作表现基于 FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里，一旦一个队列满了，我们就不能插入下一个元素，即使在队列前面仍有空间。但是使用循环队列，我们能使用这些空间去存储新的值。
数据结构学习笔记——顺序存储结构实现循环队列
小宇y的博客
06-12 4349
所谓循环队列，也就是将顺序队列中的一维数组首尾相连成环，也就是在逻辑上视为一个环连接起来，其存储类型定义与顺序队列的存储类型定义是一样的，也是定义数组data[MaxSize]和两个指针，即队头指针front指向队头元素，队尾指针rear指向队尾元素，如下： 例如下图是个空循环队列，其中data[]数组中未存任何数据元素，指针front、rear都指向同一位置，此时队列为空： 循环队列的初始化与顺序队列的初始化代码一样，当时，表示循环队列的初始状态，此时队列为空，如下代码： 三、判断循环队列是否为空队 循环
【C++】【数据结构】循环队列的基本操作（初始化、入队、出队、取队头元素、遍历输出队列、求队列长度）顺序队列的算法实现【附全代码】
热门推荐
是小雷同学的博客
04-21 2万+
C++实现循环队列的算法+步骤（附全代码）： 使用c++完成数据结构循环队列的基本操作，包括（初始化、入队、出队、取队头元素、遍历输出队列、求队列长度等），可直接编译运行。 队列又称为 “先进先出” (FIFO)线性表。限定插入操作只能在队尾进行，而删除操作只能在队首进行。 循环队列——采用顺序存储结构来实现，用一组连续的存储单元依次存放从队首到队尾的元素，附设两个整型变量front和rear分别指向队首元素和队尾元素的位置。 循环队列的定义： #define MAXQSIZE 100 typedef
队列的顺序存储实现
qq_51141456的博客
05-07 963
如上图，假设需要将元素1 到元素12 全部入队，当t元素1 到 元素10入队到队列中时，发现队列已经满了，此时元素1,2，3依次出队，头指针移动位置此时如果使用的是普通队列，想往队列中入队元素是无法入队的，因为队尾指针已经到了数组的最后一个位置；如果再入队，队尾指针加1，即图中下标为10的位置，明显不存在该位置，入队会发生错误；即使队头处有空位置，也无法入队元素，这种情况就是假溢出；所以普通队列的这种方法浪费了内存；所以下面我们使用循环队列来解决假溢出的问题；
基于C语言的循环队列实现(包含完整代码)
weixin_43369883的博客
05-18 1185
循环队列不同于非循环队列和链表,其操作不需要定义next指针,只是单纯的定义一个固定的结构体变量,此结构体中的数组变量已经可以包含全部的已定义的队列长度.(如果采用循环链表来实现队列也可行,但队列会成为可变长的)
数据结构之循环顺序队列
05-30
数据结构是计算机科学中的核心概念，它涉及到如何高效地存储和操作数据。循环顺序队列是数据结构中的一种，尤其在处理大量数据的输入输出时，它的效率和灵活性显得尤为重要。循环顺序队列是对普通顺序队列的改进，...
Python 实现数据结构-循环队列的操作方法
09-19
### Python 实现数据结构——循环队列的操作方法 #### 一、引言 在计算机科学领域，数据结构是算法设计的基础。不同的数据结构能够解决不同的问题，并且在效率上也存在差异。队列作为一种基本的数据结构，其先进先...
C++数据结构之实现循环顺序队列
12-31
数据结构–用C++实现循环顺序队列 队列的操作特性：先进先出 队列中元素具有相同类型 相邻元素具有前驱和后继关系 设置队头、队尾两个指针，以改进出队的时间性能 约定：队头指针front指向队头元素的前一个位置...
【数据结构】详解队列和循环队列
m0_52094687的博客
12-23 2570
该博客讲了队列的概念及结构，使用C语言实现队列，又简绍了循环队列，并且通过Leetcode上的一道题，实现循环队列
数据结构:循环队列的实现(leetcode622.设计循环队列)
小青菜的博客
02-22 2294
循环队列的实现
设计循环队列（图示超详解哦）
weixin_73450183的博客
03-25 1244
我们需要实现循环队列的如下接口：MyCircularQueue(k): 构造器，设置队列长度为 k；Front: 从队首获取元素。如果队列为空，返回 -1；Rear: 获取队尾元素。如果队列为空，返回 -1；enQueue(value): 向循环队列插入一个元素。如果成功插入则返回真；deQueue(): 从循环队列中删除一个元素。如果成功删除则返回真；isEmpty(): 检查循环队列是否为空；isFull(): 检查循环队列是否已满。
栈和队列的操作三——队列的顺序存储（循环队列）
m0_72619231的博客
04-06 573
下面是完整代码：😀emm...还是画个图熟悉一下顺序队列长什么样子吧。
栈与队列的几个问题与解析
m0_59691828的博客
11-11 1322
1、循环队列存储在数组A[0…m]中，则入队时的操作为：rear=(rear+1)%(m+1) 2、假设以数组A[m]存放循环队列的元素，其头尾指针分别为front和rear，则当前队列中的元素个数为：(rear-front+m)%m 3、顺序循环队列存储于数组A[n]中，它的的判空和判满条件分别为front==rear，(rear+1)%n==front 4、用带头结点的单链表存储队列，在进行出队运算时头结点指针域要修改，尾指针可能要修改 循环队列的引入，目的是为了克服 假溢出。 ...
循环队列
eRunn
10-26 159
1.问题 对于普通队列而言，数组不能重复使用，这样就造成了空间浪费。怎样才能使队列能够重复利用呢？将队列改成一个环形的，这样就可以重复利用了。 2.分析实现 分析 front 变量的含义做一个调整： front 就指向队列的第一个元素, 也就是说 arr[front] 就是队列的第一个元素 front 的初始值 = 0 rear 变量的含义做一个调整：rear 指向队列的最后一个元素的后一个...
循环队列的实现及操作
weixin_41423494的博客
10-27 463
普通的顺序队列实现有弊端（P71），用循环队列实现用来解决这一弊端，同时循环队列实现需要空出一个空间来，依次来区分队满和队空。 他的指针是不是真正的指针变量，而是int型的，用来记录数组下标，起到了指针的作用。因为只有这样才能实现取模循环 注意：循环队列的尾指针始终指Rear向下一个空间，即为指针的上一个才是存放数据的空间。            循环队列的头指针Front始终指向最后一个有...
6-1 循环队列入队出队
qq_51187952的博客
03-31 8912
6-1 循环队列入队出队 本题要求实现队列的顺序存储表示，包括入队、出队和取队头操作 函数接口定义： void EnQueue_seq(SeqQueue squeue, DataType x) ; void DeQueue_seq(SeqQueue squeue) ; DataType FrontQueue_seq(SeqQueue squeue) ; 其中，squeue 是操作的队列，x是入队的元素 裁判测试程序样例： #include <stdio.h> #incl...
数据结构与算法期中（填空选择判断题）
weixin_55765435的博客
10-29 1923
关于数据结构与算法的一些简单选填判，还希望大佬们发现和指出错误
数据结构-循环队列的基本操作与实现
最新发布
Xiao_Ya__的博客
07-11 501
数据结构-循环队列的基本操作与实现
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值