循环队列

于 2023-10-19 01:03:32 发布
阅读量395 收藏 1
点赞数
分类专栏： 数据结构 文章标签： 算法 c语言 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_74106438/article/details/133898037
版权
本文详细介绍了循环队列的定义，包括其结构、判满判空条件，以及如何通过指针操作实现入队、出队、获取元素等操作。提供了C语言的代码示例和测试案例。
摘要由CSDN通过智能技术生成

1. 定义

        同样，在实现循环队列之前，我们需要了解它的定义：循环队列就是将队列存储空间的最后一个位置绕到第一个位置，形成逻辑上的环状空间，供队列循环使用。示意图如下：

        这样的结构可以充分利用向量空间，克服”假溢出“现象。

        在循环队列中，如果队列元素数与数组内能容纳的最大元素数量MaxSize相等，当队列为空或满时，则都有front = rear。为了区分这两种情况，我们规定循环队列中最多只有MaxSize-1个元素，当front = rear时，循环队列为空，当front =（rear+1)%MaxSize时，循环队列为满。

        为什么判满条件是front =（rear+1)%MaxSize呢？

        

        如图：MaxSize = 11,当front在0，rear在10处时，循环队列已满，当rear再向下走一个位置时，应该有front = rear，但rear+1 = 11，为了让rear能重新到达0，我们需要进行取模，即：(rear+1)%MaxSize。因此，当front =（rear+1)%MaxSize，则说明队列满了。

2. 代码实现

2.1 准备工作

        为了方便后续更改循环队列中所存数据的数据类型，我们对int进行重命名，若需要更改类型，只需要更改int处即可。然后创建一个全局变量MaxSize，此处将MaxSize定为11（可自行更改），则队列的长度则为11-1=10，对于循环队列的定义，我们需要使用指针创建一个数组来表示我们的循环队列，还需要一个头指针（front）和一个尾指针(rear)来供我们进行相关操作，同时我们包含我们所需要的头文件，代码如下：

#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <stdbool.h>
#define MaxSize 11
typedef int CirQueDataType;
typedef struct CircularQueue{
    CirQueDataType *a;
    int front;//头指针
    int rear;//尾指针
}CirQue;

2.2 初始化

        在初始化时，我们需要对a分配MaxSize个CirQueDataType大小的内存，并将头尾节点都指向0位置，代码如下：

void CirQueueInit(CirQue* Que)
{
    assert(Que);
    //开辟空间
    CirQueDataType* tmp = (CirQueDataType*)malloc(sizeof(CirQueDataType) * MaxSize);
    if (NULL == tmp)//防止开辟失败
    {
        perror("malloc fail");
        return;
    }
    //初始化
    Que->a = tmp;
    Que->front = Que->rear = 0;
}

2.3 判满

        在定义部分我们已经说明了为满时的条件，代码如下：

bool CirQueueIsFull(CirQue* Que)
{
    assert(Que);
    
    return Que->front == (Que->rear + 1) % MaxSize;//满为真，未满为假
}

2.4 判空

        在定义部分我们已经说明了为空时的条件，代码如下：

bool CirQueueIsEmpty(CirQue* Que)
{
    assert(Que);
    
    return Que->front == Que->rear;//空为真
}

2.5 入队

        入队前我们需要对队列是否为满进行判定，然后将数据置于尾指针位置，尾指针加一，要注意以下情况：

若到达此位置，我们要注意：rear再+1等于11，若直接访问，则会出现越界现象，因此我们需要对其取模，即：rear++后再进行rear%=MaxSize，这样rear就可以再次到达0位置，当rear<10的时候进行取模则不会对rear的值产生影响，因此，我们再每次入队rear++后都进行取模操作：

void CirQueueEnQueue(CirQue* Que, CirQueDataType x)
{
    assert(Que);

    if (CirQueueIsFull(Que))//判满
    {
        printf("Queue is Full");
        return;
    }
    else
    {
        //入队
        Que->a[Que->rear] = x;
        Que->rear++;
        Que->rear %= MaxSize;
    }
}

2.6 出队

        出队时我们首先要防止队列已经为空，然后只需要将front+1，这样我们就访问不到出队的元素了，但同样要注意入队时产生的情况（见2.5），代码如下：

void CirQueueDeQueue(CirQue* Que)
{
    assert(Que);
    assert(Que->rear != Que->front);//防止队列为空

    Que->front = (Que->front + 1) % MaxSize;//注意同入队时一样的情况产生
}

2.7 获取头元素

        获取头元素时，首先要判断队列内是否为空，然后返回头指针对应元素即可：

CirQueDataType GetCirQueueFront(CirQue* Que)
{
    assert(Que);
    //为空打印提示并返回-1;
    if (CirQueueIsEmpty(Que))
    {
        printf("Queue is Empty");
        return -1;
    }
    else
        return Que->a[Que->front];
}

2.8 获取尾元素

        因为循环队列的长度比所创数组的长度小一，即：尾元素在尾指针的前一个位置，若想要得到尾元素的下标，我们只需要将尾指针加上队列的长度大小（感觉有点迷糊的朋友可以自己画图看一看），即rear+MaxSize-1,又考虑到可能产生入队时发生的情况（见2.5），代码如下：

CirQueDataType GetCirQueueRear(CirQue* Que)
{
    assert(Que);
    if (CirQueueIsEmpty(Que))//若为空则提示并返回-1
    {
        printf("Queue is Empty");
        return -1;
    }
    else
        return Que->a[(Que->rear + MaxSize - 1) % MaxSize];
}

2.9 打印队列中元素

void CirQueuePrint(CirQue* Que)
{
    assert(Que);
    if (CirQueueIsEmpty(Que))//若队列为空，则提示并返回
    {
        printf("队列为空\n");
        return;
    }
    //定义i = 头节点，如果i不等于尾结点，说明没有打印完
    for (int i = Que->front; i != Que->rear;)
    {
        printf("%d ", Que->a[i]);
        i++;//i走向下一个节点
        i %= MaxSize;//防止文章2.5节中的情况出现
    }
    printf("\n");
}

2.10 获取已有元素个数

int GetCirQueueLenth(CirQue* Que)
{
    assert(Que);

    int lenth = 0;
    int i = Que->front;
    while (i != Que->rear)
    {
        i++;
        i %= MaxSize;
        lenth++;
    }
    return lenth;
}

2.11 清空队列

        清空队列只需要将front和rear重新初始化为0即可：

void ClearCirQueue(CirQue* Que)
{
    assert(Que);

    Que->front = Que->rear = 0;
}

2.12 销毁队列

void DestroyCirQueue(CirQue* Que)
{
    assert(Que);

    free(Que->a);//释放数组空间
    Que->a = NULL;//头地址置空
}

3. 完整代码

3.1 CircularQueue.h

#pragma once
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <stdbool.h>
#define MaxSize 11
typedef int CirQueDataType;
typedef struct CircularQueue {
    CirQueDataType* a;
    int front;//头指针
    int rear;//尾指针
}CirQue;

void CirQueueInit(CirQue* Que);//初始化

bool CirQueueIsFull(CirQue* Que);//判满
    
bool CirQueueIsEmpty(CirQue* Que);//判空

void CirQueueEnQueue(CirQue* Que, CirQueDataType x);//入队

void CirQueueDeQueue(CirQue* Que);//出队

CirQueDataType GetCirQueueFront(CirQue* Que);//获取队首元素

CirQueDataType GetCirQueueRear(CirQue* Que);//获取队尾元素

void CirQueuePrint(CirQue* Que);//打印队列

void ClearCirQueue(CirQue* Que);//清空队列

void DestroyCirQueue(CirQue* Que);//销毁队列

int GetCirQueueLenth(CirQue* Que);//求队列长度

3.2 CircularQueue.c

#include "CirQueue.h"

void CirQueueInit(CirQue* Que)
{
    assert(Que);

    CirQueDataType* tmp = (CirQueDataType*)malloc(sizeof(CirQueDataType) * MaxSize);
    if (NULL == tmp)
    {
        perror("malloc fail");
        return;
    }
    Que->a = tmp;
    Que->front = Que->rear = 0;
}

bool CirQueueIsFull(CirQue* Que)
{
    assert(Que);

    return Que->front == (Que->rear + 1) % MaxSize;
}

bool CirQueueIsEmpty(CirQue* Que)
{
    assert(Que);
    
    return Que->front == Que->rear;
}

void CirQueueEnQueue(CirQue* Que, CirQueDataType x)
{
    assert(Que);

    if (CirQueueIsFull(Que))
    {
        printf("Queue is Full");
        return;
    }
    else
    {
        Que->a[Que->rear] = x;
        Que->rear++;
        Que->rear %= MaxSize;
    }
}

void CirQueueDeQueue(CirQue* Que)
{
    assert(Que);
    assert(Que->rear != Que->front);

    Que->front = (Que->front + 1) % MaxSize;
}

CirQueDataType GetCirQueueFront(CirQue* Que)
{
    assert(Que);
    //为空打印提示并返回-1;
    if (CirQueueIsEmpty(Que))
    {
        printf("Queue is Empty");
        return -1;
    }
    else
        return Que->a[Que->front];
}

CirQueDataType GetCirQueueRear(CirQue* Que)
{
    assert(Que);
    if (CirQueueIsEmpty(Que))
    {
        printf("Queue is Empty");
        return -1;
    }
    else
        return Que->a[(Que->rear + MaxSize - 1) % MaxSize];
}

void CirQueuePrint(CirQue* Que)
{
    assert(Que);
    if (CirQueueIsEmpty(Que))
    {
        printf("队列为空\n");
        return;
    }
        
    for (int i = Que->front; i != Que->rear;)
    {
        printf("%d ", Que->a[i]);
        i++;
        i %= MaxSize;
    }
    printf("\n");
}

void ClearCirQueue(CirQue* Que)
{
    assert(Que);

    Que->front = Que->rear = 0;
}

void DestroyCirQueue(CirQue* Que)
{
    assert(Que);

    free(Que->a);
    Que->a = NULL;
}

int GetCirQueueLenth(CirQue* Que)
{
    assert(Que);

    int lenth = 0;
    int i = Que->front;
    while (i != Que->rear)
    {
        i++;
        i %= MaxSize;
        lenth++;
    }
    return lenth;
}

3.3 test.c(测试)

#include "CirQueue.h"

void test()
{
	int Quelenth = 0;
	CirQue Que;
	CirQueueInit(&Que);
	CirQueueEnQueue(&Que, 0);
	CirQueueEnQueue(&Que, 1);
	CirQueueEnQueue(&Que, 2);
	CirQueueEnQueue(&Que, 3);
	CirQueueEnQueue(&Que, 4);
	CirQueueEnQueue(&Que, 5);
	CirQueueEnQueue(&Que, 6);
	CirQueueEnQueue(&Que, 7);
	CirQueueEnQueue(&Que, 8);
	CirQueueEnQueue(&Que, 9);
	CirQueuePrint(&Que);
	printf("%d\n", GetCirQueueFront(&Que));
	printf("%d\n", GetCirQueueRear(&Que));
	Quelenth = GetCirQueueLenth(&Que);
	
	printf("%d\n", Quelenth);
	//CirQueueEnQueue(&Que, 10);
	CirQueueDeQueue(&Que);
	CirQueueDeQueue(&Que);
	CirQueueDeQueue(&Que);
	CirQueueDeQueue(&Que);
	CirQueueDeQueue(&Que);
	CirQueueDeQueue(&Que);
	CirQueueDeQueue(&Que);
	CirQueueDeQueue(&Que);
	CirQueueEnQueue(&Que, 10);
	//CirQueueDeQueue(&Que);
	//CirQueueDeQueue(&Que);
	//CirQueueDeQueue(&Que);
	CirQueuePrint(&Que);
	printf("%d\n", GetCirQueueRear(&Que));
	Quelenth = GetCirQueueLenth(&Que);
	printf("%d\n", Quelenth);
	ClearCirQueue(&Que);
	CirQueuePrint(&Que);
	DestroyCirQueue(&Que);
}

int main()
{
	test();
	return 0;
}

       

         好了，本次文章内容就到这里啦，谢谢各位，如有错误欢迎各位指正，我们下篇文章再见！

晨辰丷
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
循环队列,新建循环队列（Maxsize为5），读取标准输入3 4 5 6 7，入队7时，队满，打印false，然后依次出队，输出 3 4 5 6
PJCDH的博客
05-07 268
循环队列进队出队两个判断条件 1.队空Q.front==Q.rear 2.队满Q.front == (Q.rear + 1) % MaxSize %在这里是取余运算,例如x%9=(0,1,2,3,4,8) 这样可以将结果头尾相接 #define _CRT_SECURE_NO_WARNINGS #include<stdio.h> #define MaxSize 5 typedef int Element; typedef struct Duilie { Element data[MaxSi
循环队列中计算队列元素时加上MaxSize的原因
从日安声
06-01 1655
因为循环队列是个圈，队尾索引减去队头索引时可能会出现负数，加上MaxSize就可以避免这种情况。
数据结构：循环队列（C语言实现）
热门推荐
lpp0900320123的专栏
03-07 12万+
生活中有很多队列的影子，比如打饭排队，买火车票排队问题等，可以说与时间相关的问题，一般都会涉及到队列问题；从生活中，可以抽象出队列的概念，队列就是一个能够实现“先进先出”的存储结构。队列分为链式队列和静态队列；静态队列一般用数组来实现，但此时的队列必须是循环队列，否则会造成巨大的内存浪费；链式队列是用链表来实现队列的。这里讲的是循环队列，首先我们必须明白下面几个问题 一、循环队列的基础知识 1
第 3 章：稀疏数组和队列
Oneby的博客
07-25 4973
第 3 章：稀疏数组和队列 1、稀疏数组 1.1、实际需求 编写的五子棋程序中，有存盘退出和续上盘的功能 因为该二维数组的很多值是默认值 0 ，因此记录了很多没有意义的数据，我们将其转为稀疏数组进行存储 1.2、稀疏数组应用 1.2.1、稀疏数组处理方法 稀疏数组把具有不同值的元素的行列及值记录在一个小规模的数组中，从而缩小程序的规模 稀疏数组也是二维数组，行数由原数组的数据决定，列数一般为 3 列 稀疏数组的第一行记录原数组一共有几行几列，有多少个不为零的值 第一列：原数组的行数 第二列：原数组
C++实现循环队列
08-25
C++实现循环队列 C++实现循环队列是指使用C++语言来实现循环队列数据结构。循环队列是一种特殊的队列结构，能够循环使用队列中的元素，从而提高了队列的使用效率。 在C++中，实现循环队列可以使用模板类来实现。...
c++循环队列
07-24
**C++循环队列详解** 循环队列是一种特殊类型的线性数据结构，它在物理存储上是连续的，但在逻辑上表现为一个环形结构。在循环队列中，队尾指针可以在达到数组长度后“回绕”到数组的开头，从而实现循环的效果。...
Java循环队列原理与用法详解
08-19
Java循环队列原理与用法详解 Java循环队列是一种高效的数据结构，它可以解决顺序队列中删除队首元素时的时间复杂度O(n)问题。下面我们将详细讲解Java循环队列的原理、用法及实现。 Java循环队列的原理 在顺序队列...
C语言循环队列
11-09
C语言实现循环对列，思路清晰。编译环境VC 2008下可编译通过。
如何实现循环队列
12-31
静态队列一般用数组来实现，但此时的队列必须是循环队列，否则会造成巨大的内存浪费；链式队列是用链表来实现队列的。 #ifndef SQQUEUE_H_INCLUDED #define SQQUEUE_H_INCLUDED /* 防止重复包含 */ //////////////...
数组队列及循环队列
一个猿子的博客
10-03 484
java数据结构之----数组队列及循环队列 数据结构与算法学习的第二篇 什么时候需要用到队列 队列在实际开发过程中运用的非常广泛，由于我也是学习基础，还没有开发过什么项目，所以用到时候就知道了 什么是队列 队列是一个有序列表，可以用数组或者链表来实现 队列遵守先入先出的原则 联系实际场景 可以把一个队列的存入，读取数据的过程看成在银行里面排队办理业务，进银行，取号，叫号，办理业务，出银行...
数据结构之队列
m0_58290966的博客
01-12 690
目录 #一、队列的使用场景 二、普通队列介绍 #三、数组实现队列 #四、存在的问题 #五、循环队列 一、队列的使用场景 队列在日常生活中十分常见。银行叫号系统、排队等都是队列的应用。 排队的原则是先来后到，即先来的人可以优先办理业务，先离开；排在后面的人需要等待。 二、普通队列介绍 队列是一个有序列表，可以用数组或链表来实现。 遵循先入先出的原则。即：先进入队列中的数据先取出。后进入队列的数据后取出。 三、数组实现队列 front 是队列最前元素之前的一个位置。
循环队列的实现方式详解(三种处理方式)
晓魏
03-15 2337
使用数组的方式实现 循环队列本质是一种队列，具有FIFO的数据结构； 把数组想象成为一个一个环状的空间，就是把存储队列元素从逻辑上看作一个环，成为循环队列； 在数组中操作才能表现成环状的逻辑结构呢？ 使用除法的取余运算； ...
数组模拟队列的实现
qq_40823802的博客
08-07 219
队列本身是有序列表，若使用数组的结构来存储队列的数据，则队列数组的声明如下图，其中maxSize是该队列的最大容量。 因为队列的输出、输入是分别从前后段来处理，因此需要两个变量front及rear分别记录队列前后端的下标，front会随着数据输出而改变，而rear则是随着数据输入而改变，如图所示： ...
循环队列中公式的推导，原理，超详解
Error的博客
03-18 3923
我这里讲的是空闲单元法，如下图 首先规定 : front指向队列第一个元素 rear指向队列最后一个元素的下一个位置 假设maxsize=10 因为循环，需要保证front和rear的值始终在0-9之间循环，由此想到取余即% a%b当a<b时结果为a,a>=0,b>0 ，于是有了下方： rear=rear%maxsize front=front%maxsize 以下所有的操作都是rear和rear%maxsize，front和front%maxsize相互之间的替换
数据结构与算法~概述与队列
weixin_48035827的博客
01-06 448
数据结构~概述与队列
队列文档之循环队列
二木成林
05-09 8204
循环队列就是将顺序队列臆造成一个环状的空间（实际上不是，只是把它看成是环状的），即把存储队列元素的顺序表从逻辑上视为一个环。
队列——顺序存储结构实现( 循环队列 - 不同指针指向)
一个很懒的人
07-29 6087
0.概述 本文首先以思维导图介绍队列的基本知识，其次给出循环队列（顺序存储结构）首尾不同指针指向不同位置时，队列的判空和判满条件，最后给出三种不同指针指向的循环队列代码实现！ 链式队列实现，请参考我的另一篇博客：: 队列——链式存储结构实现. 1.基本知识 2.不同指针指向，队列判空/判满条件 1. rear:指向队尾元素 front:指向队头元素前一个位置 （1）牺牲一个存储空间 （2）判空条件：front == rear （3）判满条件：(rear+1)%MaxSize == fron.
四、队列 顺序队列和链式队列 详解
weixin_43827227的博客
09-18 2321
目录 队列 队列的顺序存储结构 队列的链式存储结构 入队操作 出队操作 队列 队列的顺序存储结构 队列队列，顾名思义就是平常我们排队的时候的一种结构，下面JV带你详细看看它的定义。 队列（queue）是只允许在一端进行插入操作（队尾），而在另一端进行删除操作（队头）的线性表。它先进先出（First In First Out），就像排队一样。 为什么删除操作是O(n)呢？...
循环队列 educoder
最新发布
10-30
educoder是一种特殊的数据结构，是一种循环队列。 队列是一种先进先出（FIFO）的数据结构，而循环队列是在队列基础上进行了优化。循环队列中的元素按照先进先出的顺序排列，并且队列的首尾是相连的，形成一个圆环。...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值