数据结构之循环队列详解

最新推荐文章于 2024-04-22 14:48:17 发布
最新推荐文章于 2024-04-22 14:48:17 发布
阅读量3.4k 收藏 34
点赞数 6
分类专栏： C++数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44517656/article/details/115605127
版权

队列分为顺序队列和循环队列，顺序队列的实现有很多种方法，有数组和链表。数组实现的又分为使用队头队尾front，rear实现和利用一个变量size统计队列元素大小实现等等。并且关于size实现的顺序队列(数组和链表都实现过)我之前的数据结构文章已经实现过。

顺序队列我们可以使用排队买车票进行理解。

在讲循环队列之前，我们先讲一下顺序队列的假溢出。

1 顺序队列的假溢出

在这里插入图片描述

1️⃣：初始化空队列，q -> front = q -> rear = 0。

2️⃣：入队a1、a2、a3，q -> front = 0, q -> rear = 3 。

3️⃣：出队a1、a2，q -> front = 2, q -> rear = 3 。

4️⃣：入队a4、a5、a6，q -> front = 2, q -> rear = 6 。

但是执行 4️⃣ 操作后队列的"尾指针"已经超出对队列的最大范围了，之后无法再进行入队操作，而队列实际空间并未占满，就造成了假溢出。

解决上述溢出的方法

  1. 将队中元素依次向队头方向移动。
  2. 将队列空间设想成一个循环的表，即分配给队列的 m 个存储单元可以循环使用，当 rear 指向 MAXSIZE 时，若队列的开始端空着，又可从头使用空着的空间。当 front 为 MAXSIZE 时也是一样。

我们采用第2种方法，所以接下来第5步有：
5️⃣：入队a7，q -> front = 2, q -> rear = 0 。
在这里插入图片描述

2 循环队列

通过上面的解释，为了解决顺序队列的假溢出，所以我们需要引入循环队列来解决。
循环队列概念：
无论是插入还是删除，rear增加1或者front增加1，若超出所分配的空间，就让它指向这片空间的起始地址。
实现方法： 利用 模或者称为取余(mod，C语言中：%)运算。

2.1 插入元素

// 队尾入队
q -> base[q -> rear] = data;
// 更新队尾指针
q -> rear = (q -> rear + 1) % MAXSIZE;

2.2 删除元素
无论是插入还是删除，都是加1后取余。

// 队头元素出队
data = q -> base[q -> front];
// 更新队头指针
q -> front = (q -> front + 1) % MAXSIZE;

3 解决循环队列的判空、判满冲突

我们熟悉循环队列的人都知道，循环队列为空或者为满时，front都是等于rear，例如上面例子，一开始为空时，front=rear=0，当填满6个元素，rear=5+1%6=0，又变回了0。

解决方案：

  • 1）另外设一个标致位以区别队空、队满。
  • 2）另设一个变量，记录元素个数。
  • 3）少用一个元素空间。

本文实现的方法就是第三种，但个人建议在实际使用时，更倾向使用第二种，因为它更为方便容易理解。

下图可以看到，当我们少用一个队列的空间时，当队满时必有(q->rear+1)%MAXSIZE = q->front。而为空时front=rear，这样就区分了循环队列判满和判空的情况。
在这里插入图片描述

3.1 循环队列常规操作

/********************* 循环队列的常规操作 **************************/

Queue    InitQueue();             	// 初始化循环队列
int      QueueFull();               // 循环队列判满
int      QueueEmpty();              // 循环队列判空
int      QueueLength();             // 求循环队列长度(元素个数)
int      EnQueue();                 // 循环队列 入队
int      DeQueue();                 // 循环队列 出队

void     QueueStatus();             // 打印队满、队空、队长状态
/****************************************************************/

3.2 定义循环队列结构体

#include "stdio.h"
#include "malloc.h"

#define TRUE  1
#define FALSE 0
#define MAXSIZE 10

typedef int ElemType;


// 定义循环队列结构体
typedef struct Queue {

	int *base;	// 队列首地址
	int front;	// 队列头下标
	int rear;	// 队列尾下标

}QueObj,*Queue;
//定义了结构体对象和结构体指针的形式。

3.3 初始化循环队列

/*
 * 初始化循环队列
*/
Queue InitQueue() {
	Queue q;
	q = malloc(sizeof(QueObj));
	// 分配循环队列空间
	q->base = (ElemType *)malloc(sizeof(ElemType) * MAXSIZE);
	q->front = q->rear = 0;
	return q;
}

3.4 释放循环队列

/*
* 释放队列结构体
*/
void FreeQueue(Queue q) {
	if (NULL != q) {
		if (NULL != q->base) {
			free(q->base);
			q->base = NULL;
		}
		free(q);
		q = NULL;
	}
}

3.5 循环队列判满
注意，循环队列判满是我们上述说的少用一个元素空间的关键，因为它预先进行了+1操作，这样就能保证当rear指向队列尾部时，若再加1取余为0，说明队列为满。例如上述，当rear=5时，由于此时还没存进元素，所以下一次插入元素时，rear=(5+1)%6==q->front，即等于0，所以此时队列为满，即6个空间存进了5个元素。
具体看下面的例子。

/*
 *  循环队列判满
 *  q 循环队列
*/
int QueueFull(Queue q) {
	if (q == NULL) {
		return FALSE;
	}
	return (q->rear + 1) % MAXSIZE == q->front;
}

3.6 循环队列判空

/*
 *  循环队列判空
 *  q 循环队列
*/
int QueueEmpty(Queue q) {
	if (q == NULL) {
		return FALSE;
	}
	return q->front == q->rear;
}

3.7 计算循环队列的长度
按照正常逻辑，计算队列长度只需要队尾减去队头即可，但是由于是循环队列，可能存在front大，rear小运算得出负数的情况，所以必须通过加上MAXSIZE再取余保证队列的大小为正数。

/*
 *  计算循环队列长度
 *  q 循环队列
*/
int QueueLength(Queue q) {
	if (q == NULL) {
		return FALSE;
	}
	return (q->rear - q->front + MAXSIZE) % MAXSIZE;
}

3.8 循环队列入队（EnQueue）
下面可以看到，每次入队前都会判断循环队列是否为满，QueueFull与EnQueue是保证队列少一元素的关键。

/*
 *  循环队列 入队
 *  q 循环队列
 *  data 入队元素
*/
int EnQueue(Queue q, ElemType data) {
	if (QueueFull(q)) {
		return FALSE;
	}
	// 队尾入队
	q->base[q->rear] = data;
	// 更新队尾指针
	q->rear = (q->rear + 1) % MAXSIZE;
	return TRUE;
}

3.9 循环队列出队（DeQueue）

/*
 *  循环队列 出队
 *  q 循环队列
 *  *val 用来存出队元素的数据
*/
int DeQueue(Queue q, ElemType *val) {
	if (QueueEmpty(q)) {
		return FALSE;
	}
	// 队头元素出队
	*val = q->base[q->front];
	// 更新队头指针
	q->front = (q->front + 1) % MAXSIZE;
	return TRUE;
}

3.10 打印队满、队空、队长状态

/*
 * 打印队满、队空、队长状态
 * q 顺序队列
*/
void QueueStatus(Queue q) {
	printf("QueueFull():%d\n", QueueFull(q));
	printf("QueueEmpty():%d\n", QueueEmpty(q));
	printf("QueueLength():%d\n", QueueLength(q));
}

3.11 打印队列中的元素

/*
 * 打印队列中的元素
*/
void PrintQueue(Queue q) {
	if (NULL == q || NULL == q->base) {
		return;
	}
	if (QueueEmpty(q)) {
		printf("Current element of array is NULL\n");
		return;
	}
	
	//注意，由于我们判断队列满的时侯是进行+1判断的(看QueueFull函数)，所以这里必须-1打印元素
	//若不减1，则队列尾部的元素为很大的负数
	for (int i = 0; i < MAXSIZE - 1; i++) {
		printf("%d ", q->base[i]);
	}
	printf("\n");
}

4 循环队列的测试

#include "stdio.h"
#include "malloc.h"

#define TRUE  1
#define FALSE 0
#define MAXSIZE 10

typedef int ElemType;


// 定义循环队列结构体
typedef struct Queue {

	int *base;	// 队列首地址
	int front;	// 队列头下标
	int rear;	// 队列尾下标

}QueObj,*Queue;


/*
 * 初始化循环队列
*/
Queue InitQueue() {
	Queue q;
	q = malloc(sizeof(QueObj));
	// 分配循环队列空间
	q->base = (ElemType *)malloc(sizeof(ElemType) * MAXSIZE);
	q->front = q->rear = 0;
	return q;
}

/*
* 释放队列结构体
*/
void FreeQueue(Queue q) {
	if (NULL != q) {
		if (NULL != q->base) {
			free(q->base);
			q->base = NULL;
		}
		free(q);
		q = NULL;
	}
}

/*
 *  循环队列判满
 *  q 循环队列
*/
int QueueFull(Queue q) {
	if (q == NULL) {
		return FALSE;
	}
	return (q->rear + 1) % MAXSIZE == q->front;
}


/*
 *  循环队列判空
 *  q 循环队列
*/
int QueueEmpty(Queue q) {
	if (q == NULL) {
		return FALSE;
	}
	return q->front == q->rear;
}


/*
 *  计算循环队列长度
 *  q 循环队列
*/
int QueueLength(Queue q) {
	if (q == NULL) {
		return FALSE;
	}
	return (q->rear - q->front + MAXSIZE) % MAXSIZE;
}


/*
 *  循环队列 入队
 *  q 循环队列
 *  data 入队元素
*/
int EnQueue(Queue q, ElemType data) {
	if (QueueFull(q)) {
		return FALSE;
	}
	// 队尾入队
	q->base[q->rear] = data;
	// 更新队尾指针
	q->rear = (q->rear + 1) % MAXSIZE;
	return TRUE;
}


/*
 *  循环队列 出队
 *  q 循环队列
 *  *val 用来存出队元素的数据
*/
int DeQueue(Queue q, ElemType *val) {
	if (QueueEmpty(q)) {
		return FALSE;
	}
	// 队头元素出队
	*val = q->base[q->front];
	// 更新队头指针
	q->front = (q->front + 1) % MAXSIZE;
	return TRUE;
}

/*
 * 打印队满、队空、队长状态
 * q 顺序队列
*/
void QueueStatus(Queue q) {
	printf("QueueFull():%d\n", QueueFull(q));
	printf("QueueEmpty():%d\n", QueueEmpty(q));
	printf("QueueLength():%d\n", QueueLength(q));
}


/*
 * 打印队列中的元素
*/
void PrintQueue(Queue q) {
	if (NULL == q || NULL == q->base) {
		return;
	}
	if (QueueEmpty(q)) {
		printf("Current element of array is NULL\n");
		return;
	}
	
	//注意，由于我们判断队列满的时侯是进行+1判断的(看QueueFull函数)，所以这里必须-1打印元素
	//若不减1，则队列尾部的元素为很大的负数
	for (int i = 0; i < MAXSIZE - 1; i++) {
		printf("%d ", q->base[i]);
	}
	printf("\n");
}


int main(int argc, char const *argv[])
{
	Queue q = InitQueue();
	printf("QueueMaxSize: %d\n", MAXSIZE);
	QueueStatus(q); // 打印队满、队空、队长状态
	PrintQueue(q);


	printf("\n\n");


	// 入队
	printf("EnQueue():");
	for (int i = 1; i < MAXSIZE * 2; i += 2) {
		EnQueue(q, i);
	}
	printf("\n");
	QueueStatus(q);
	PrintQueue(q);


	printf("\n\n");


	// 出队
	int val;
	printf("DeQueue():");
	while (!QueueEmpty(q)) {
		DeQueue(q, &val);
	}
	printf("\n");
	QueueStatus(q);
	PrintQueue(q);


	printf("\n\n");


	// 测试循环队列是否会假溢出
	//结果不会，因为此时rear=front=9，当执行(q->rear + 1) % MAXSIZE == q->front;会返回0
	//所以EnQueue可以往队列中插入元素返回1。然后更新rear=1，也就说rear不会由9变成10造成假溢出。
	int num = 20;
	printf("EnQueue(%d): %d\t(0 mean Failed, 1 mean Success)\n", num, EnQueue(q, num));
	QueueStatus(q);


	//释放
	FreeQueue(q);
	return 0;
}

程序结果如下：
在这里插入图片描述

5 总结循环队列

  • 1）关于循环队列的原理和实现我们已经熟悉，但是个人认为在实现循环队列时更建议使用变量区分判满和判空，优点有队列能保证有多大就存多大的元素，并且更容易理解。
  • 2）而使用少一个元素空间，其关键在于判断满时预先+1取余判断，虽然可以少一个变量区分判满判空，但是不习惯的可能不易于理解。

参考文章：
C语言实现循环队列

Mango酱
关注
  • 6
    点赞
  • 踩
  • 34
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构（超详细讲解！！）第十五节 队列（循环队列）
2201_76115387的博客
10-22 429
顺序队列
Python二级--循环队列专题
zns972630879的博客
11-24 5254
Python二级--循环队列专题
计算机二级c++试题分析 循环队列
荣耀与梦想来日方长
03-10 1743
循环队列元素个数计算
数据结构——循环队列（C++实现）
最新发布
qq_67693066的博客
04-22 770
数据结构——循环队列（C++）
循环队列的初始化，入队，出队，求队长，取队头元素
数据结构学习
12-02 4854
1.要会判断队满： if((Q.rear+1)%MAXQSIZZE == Q.front){//判断队满 return ERROR; }
循环队列中公式的推导，原理，超详解
Error的博客
03-18 3892
我这里讲的是空闲单元法，如下图 首先规定 : 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相互之间的替换
JavaScript数据结构之优先队列与循环队列实例详解
10-19
优先队列和循环队列是两种重要的数据结构，在JavaScript中有着广泛的应用。它们分别用于处理具有不同优先级的元素和实现高效循环访问的序列。下面将详细介绍这两种数据结构的原理、定义以及如何在JavaScript中实现。...
详解数据结构C语言实现之循环队列
12-31
本文讲的是循环队列，首先我们必须明白下面几个问题 循环队列的基础知识 1.循环队列需要几个参数来确定 循环队列需要2个参数，front和rear 2.循环队列各个参数的含义 （1）队列初始化时，front和rear值都为零；...
C#数据结构之队列(Quene)实例详解
09-03
在C#中，数据结构是计算机科学中存储和组织数据的一种方式。队列是一种线性数据结构，遵循“先进先出”（FIFO）的原则，这意味着最早被添加到队列中的元素将首先被移除。队列在许多编程场景中都有广泛的应用，如任务...
循环队列的初始化、入队和出队操作
m0_73481418的博客
05-03 1255
输出时：第一行和最后一行输出循环队列元素值及其下标（元素值（下标）），若中途出现队空或队满，则应给出相应提示。输入时：第一行输入队列数据空间容量，第二行依次输入5个待插入元素值，第三行再依次输入5个待插入元素值。接口参数: Q是循环队列， N 是队列数组空间容量， x是入队元素， e用于接收出队元素的值。//输入循环队列空间大小。//输出队列元素及其下标位置。printQ(Q);//输出队列中的各元素。/* 请在这里填写答案 */
循环队列的一些问题总结，入队、出队操作
BUstar_wzq的博客
02-02 1万+
在复习数据结构——队列这一节时遇到了一些问题，现总结如下，以便以后查阅： 1.在队列的顺序存储方式里，为了避免存储空间的“假溢出”，充分利用存储空间，我们用了一种实现方式，即循环队列。 (1).图中有两个指针(只是两个整型变量，因为在这里有指示作用，所以理解为指针) front、rear，一个指示队头，一个指示队尾（这里注意：rear定义为指向队尾元素还是队尾元素的下一个空间）。 (2).rea...
队列之循环队列详解（C语言版）
热门推荐
qq_44075108的博客
02-15 2万+
本篇文章详细的介绍了数据结构队列中的循环队列，并用C语言对其常用操作进行了实现。
王道考研数据结构--4.2循环队列
我是个好人呀，????
07-25 483
日期：2023.7.25书籍：2024年数据结构考研复习指导（王道考研系列）内容：实现顺序队列的基本实现，主要功能如下：1.循环队列的数据结构2.入队3.出队4.遍历5.求队长6.清空，销毁顺序队列在使用过程中容易出现虚假的满状态， 为了解决这个问题，就产生了一个较巧妙的方法，将顺序队列臆造为一个环状的空间，称之为循环队列。循环队列中指针和队列元素之间的关系不变，我们只需要利用模运算就可以很容易实现指针的循环移动。
队列、循环队列、双端队列详解（含完整代码）
m0_60284144的博客
04-24 2760
队列是一种操作受限的线性表。只允许在表的一端进行插入，在表的另一端进行删除。和日常生活中的队列一样 先入队的元素优先出队，即先进先出。
队列文档之循环队列
二木成林
05-09 8166
循环队列就是将顺序队列臆造成一个环状的空间（实际上不是，只是把它看成是环状的），即把存储队列元素的顺序表从逻辑上视为一个环。
初始化循环队列、添加元素、打印循环队列
heibusi的博客
05-11 1480
初始化循环队列、添加元素、打印循环队列 学习队列重要的是理解如何判空、如何判断队满以及如何得出循环队列的元素个数。还应该知道为什么11个元素容量的循环队列一般只放10个元素。这些如果能够理解了，增删改查就都明白了。请看代码，我已将重要的东西注释出来了哦！！！！ #include <stdio.h> #include <iostream> #define maxsize 10 using namespace std; //利用受限顺序表来表示队列 typedef struct queu
循环队列work
qq_36560939的博客
05-16 885
循环队列 //定义循环队列 typedef struct CircleIntQueue { int data[TOTAL_SPACE]; int head; int tail; } *CircleIntQueuePtr; /生成循环链表 CircleIntQueuePtr initQueue() { CircleIntQueuePtr resultPtr = (CircleIntQueuePtr)malloc(sizeof(struct CircleIntQueue)); resultPt
【无标题】循环队列元素个数计算
qq_69764094的博客
04-23 3893
某循环队列的存储空间为Q(1:m)，初始状态为front=rear=m。现经过一系列的入队操作和退队操作后，front=m，rear=m-1，则该循环队列中的元素个数为（C）。 A、1 B、m C、m-1 D、0 设循环队列的存储空间为Q(1:m)，初始状态为空。在循环队列运转起来后，如果rear-front>0，则队列中的元素个数为rear-front个；如果rear-front<0则队列中的元素个数为rear-front+m个。 即： ...
数据结构之循环队列
AHuRui的博客
05-16 2029
文章目录一、循环队列结构体的定义：二、相关操作实现1.初始化2.依次对栈中的每个数据元素输出3.进队列4.出队列5.链队列中元素个数6.测试函数7.具体代码实现三、样例输出四、写在最后 循环队列 这里是数据结构个人学习的笔记记录，如有问题欢迎指正说明 一、循环队列 循环队列就好比我们乘坐公交车，当我们上车发现车后面坐满了而前面还有空座的时候，肯定不是说下车等下一俩，而是后面没座了那我就坐前面呗，循环队列解决的就是这样一个问题。因此我们将队列头尾相接的顺序存储结构称为循环队列。 先来定义循环队列的结
数据结构 顺序循环队列
08-04
顺序循环队列是一种使用顺序存储结构实现的队列。它通过将队列的首尾相连，构成一个循环的结构，解决了普通队列在出队操作时需要移动元素的问题，提高了算法效率。[2] 顺序循环队列的结构定义如下： ```c #define SIZE 8 typedef struct Queue { int elem[SIZE]; // 存放队列元素 int front; // 队头 int rear; // 队尾 } Queue, *QueueS; ``` 其中，`elem`数组用于存放队列元素，`front`表示队头的位置，`rear`表示队尾的位置。当队列为空时，`front`和`rear`的值相等；当队列满时，`rear`的下一个位置就是`front`。通过这种方式，可以实现循环利用队列的存储空间。 顺序循环队列的操作包括入队和出队操作。入队操作将元素插入到队尾，同时更新`rear`的位置；出队操作将队头元素删除，同时更新`front`的位置。当队列满时，无法进行入队操作；当队列为空时，无法进行出队操作。因此，需要额外的判断条件来判断队列是否满或为空。 顺序循环队列的实现可以通过取模运算来实现循环的效果，即在计算`rear`和`front`的位置时，使用`(rear + 1) % SIZE`和`(front + 1) % SIZE`来计算新的位置。 总结来说，顺序循环队列是一种通过循环利用队列存储空间来提高算法效率的数据结构。它使用顺序存储结构实现，通过将队列的首尾相连构成循环结构，解决了普通队列在出队操作时需要移动元素的问题。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值