详解循环队列

已于 2023-10-26 18:51:12 修改
阅读量6.3k 收藏 13
点赞数 7
文章标签： 算法 数据结构
于 2023-10-26 18:49:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_53454890/article/details/134062299
版权
本文介绍了循环队列这一数据结构，它由固定大小数组和双指针组成，具有循环性质。其特点包括高效的入队和出队操作、可判空和判满等。文中阐述了初始化、入队、出队等基本运算，还给出代码实现及完整代码，适用于周期性循环存储数据场景。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

一.定义

循环队列是一种队列数据结构，由固定大小的数组组成，其中包括两指针，"front" 和 "rear"，以管理队列元素。其特点在于队列具有循环性质，即在"rear"指针达到数组末尾时，下一个元素将从数组开头插入。它支持高效的入队和出队操作，能判断队列的空和满状态，通常应用于需要周期性循环存储数据的场景。

二.特点

  1. 固定大小的数组：循环队列使用固定大小的数组来存储元素。这个数组的大小在创建队列时就确定，通常不会动态扩展或缩小。

  2. 循环性质：循环队列的一个关键特点是它的队列是循环的。当"rear"指针到达数组的末尾时，下一个元素将从数组的开头插入。这意味着队列可以循环利用数组的空间，避免了数组满了之后无法插入新元素的问题。

  3. 双指针：循环队列使用两个指针，分别是"front"（前指针）和"rear"（后指针）。"front"指针指向队列的第一个元素，"rear"指针指向队列的最后一个元素。这些指针的位置关系可以用来判断队列的状态（空或满）以及执行入队和出队操作。

  4. 高效的入队和出队操作：由于循环队列的特性，入队和出队操作通常非常高效。入队操作只需在"rear"指针指向的位置插入元素并移动"rear"指针，出队操作只需移除"front"指针指向的元素并移动"front"指针。这些操作的时间复杂度通常是O(1)。

  5. 判空和判满：循环队列有两种状态，即空队列和满队列。你可以使用指针的位置关系来判断队列是否为空（"front" == "rear"）或满（("rear" + 1) % 数组大小 == "front"）。

  6. 有限大小：由于数组大小是固定的，循环队列的容量有限。这意味着在队列满时，无法再插入更多元素，除非出队一些元素来腾出空间。

  7. 适用于环形数据存储需求：循环队列通常用于需要周期性地循环存储数据的应用场景，如缓冲区管理、任务调度等。

  8. 需要小心管理大小和元素数量：由于固定的容量，循环队列需要小心管理队列的大小和元素数量，以避免数据溢出或元素丢失的问题。

总之，循环队列是一种高效的队列数据结构，适用于需要快速入队和出队操作的情况，但需要谨慎处理队列的大小和元素数量以确保正常运作。

三.基本运算

  1. 初始化：创建一个循环队列时，需要初始化队列的数组大小，以及"front" 和 "rear" 指针的初始位置。通常，"front" 和 "rear" 初始化为相同的值，表示空队列。

  2. 入队操作：入队操作用于将元素添加到队列中。这包括将元素插入到"rear"指针所指向的位置，然后将"rear"指针向后移动。如果队列已满（即"rear" + 1 等于 "front"，考虑循环性质），则入队操作失败。

  3. 出队操作：出队操作用于移除队列中的元素。这包括从"front"指针所指向的位置移除元素，然后将"front"指针向后移动。如果队列为空（即"front" 和 "rear" 指向相同位置），则出队操作失败。

  4. 判空和判满：通过检查"front" 和 "rear" 指针的位置关系，可以判断队列是否为空（"front" == "rear"）或满（("rear" + 1) % 数组大小 == "front"，考虑循环性质）。

  5. 获取队列大小：可以通过计算"rear"和"front"指针的位置关系来获取队列中元素的数量。

这些是循环队列的基本运算，它们使队列能够高效地支持元素的插入和删除，并提供了对队列状态的判断。循环队列的特点在于可以循环利用数组的空间，从而更有效地管理队列中的元素。

四.代码实现

1.定义接口

#define MAXSIZE 100

typedef int DataType;

typedef struct
{
	DataType data[MAXSIZE];
	int front;
	int rear;
}CirclesQueue;

/*循环队列初始化*/
int init(CirclesQueue *Q);

/*入队*/
int enqueue(CirclesQueue *Q, DataType x);

/*队满*/
int isfull(CirclesQueue *Q);

/*出队*/
int dequeue(CirclesQueue *Q, DataType *);

/*队空*/
int isempty(CirclesQueue *Q);

// 输出队列内容  
void printQueue(CirclesQueue *Q);

// 获取队列长度  
int getLength(CirclesQueue *Q);

// 获取队首元素
DataType getFront(CirclesQueue* Q);

2.初始化

/*循环队列初始化*/
int init(CirclesQueue *Q)
{
	Q->front = Q->rear = 0;
	return 0;
}

3.入队

/*入队*/
int enqueue(CirclesQueue *Q, DataType x)
{
	if(isfull(Q))
	{
		printf("队列已满！100001\n");
		return 100001;
	}

	Q->rear = (Q->rear+1) % MAXSIZE;
	Q->data[Q->rear] = x;
	return 0;
}

4.队满

/*队满*/
int isfull(CirclesQueue *Q)
{
	return (Q->rear+1)%MAXSIZE == Q->front ? 1 : 0;
}

5.出队

/*出队*/
int dequeue(CirclesQueue *Q, DataType *x)
{
	if(isempty(Q))
	{
		printf("队列为空！100002\n");
		return 100002;
	}
	Q->front = (Q->front+1) % MAXSIZE;
	*x = Q->data[Q->front];
	return 0;
}

6.队空

/*队空*/
int isempty(CirclesQueue *Q)
{
	return (Q->front == Q->rear) ? 1 : 0;
}

7.输出队列内容

// 输出队列内容  
void printQueue(CirclesQueue *Q) {
    int i;
    if (isempty(Q)) {  
        printf("Queue is empty.\n");  
        return;  
    }  
    i = (Q -> front) %MAXSIZE;
    do{
        printf(" %d",Q -> data[(i + 1 % MAXSIZE)]);
        i = (i+1) %MAXSIZE;
    }while(i != Q -> rear);
}

8.获取队列长度

// 获取队列长度  
int getLength(CirclesQueue *Q) {  
    return (Q->rear - Q->front + MAXSIZE) % MAXSIZE; // 循环队列：若rear在前方，则长度为rear-front+MAXSIZE，否则为rear-front  
}

9.获取队首元素

// 获取队首元素  
DataType getFront(CirclesQueue* Q) {  
    int i;
    i = (Q -> front) %MAXSIZE;
    return Q -> data[(i + 1 % MAXSIZE)];
}

五.运行截图

 六.完整代码

1.CirclesQueue.h
#define MAXSIZE 100

typedef int DataType;

typedef struct
{
	DataType data[MAXSIZE];
	int front;
	int rear;
}CirclesQueue;

/*循环队列初始化*/
int init(CirclesQueue *Q);

/*入队*/
int enqueue(CirclesQueue *Q, DataType x);

/*队满*/
int isfull(CirclesQueue *Q);

/*出队*/
int dequeue(CirclesQueue *Q, DataType *);

/*队空*/
int isempty(CirclesQueue *Q);

// 输出队列内容  
void printQueue(CirclesQueue *Q);

// 获取队列长度  
int getLength(CirclesQueue *Q);

// 获取队首元素
DataType getFront(CirclesQueue* Q);
2.CirclesQueue.c
#include <stdio.h>
#include "CirclesQueue.h"

/*循环队列初始化*/
int init(CirclesQueue *Q)
{
	Q->front = Q->rear = 0;
	return 0;
}


/*入队*/
int enqueue(CirclesQueue *Q, DataType x)
{
	if(isfull(Q))
	{
		printf("队列已满！100001\n");
		return 100001;
	}

	Q->rear = (Q->rear+1) % MAXSIZE;
	Q->data[Q->rear] = x;
	return 0;
}

/*队满*/
int isfull(CirclesQueue *Q)
{
	return (Q->rear+1)%MAXSIZE == Q->front ? 1 : 0;
}


/*出队*/
int dequeue(CirclesQueue *Q, DataType *x)
{
	if(isempty(Q))
	{
		printf("队列为空！100002\n");
		return 100002;
	}
	Q->front = (Q->front+1) % MAXSIZE;
	*x = Q->data[Q->front];
	return 0;
}

/*队空*/
int isempty(CirclesQueue *Q)
{
	return (Q->front == Q->rear) ? 1 : 0;
}

// 输出队列内容  
void printQueue(CirclesQueue *Q) {
    int i;
    if (isempty(Q)) {  
        printf("Queue is empty.\n");  
        return;  
    }  
    i = (Q -> front) %MAXSIZE;
    do{
        printf(" %d",Q -> data[(i + 1 % MAXSIZE)]);
        i = (i+1) %MAXSIZE;
    }while(i != Q -> rear);
}

// 获取队列长度  
int getLength(CirclesQueue *Q) {  
    return (Q->rear - Q->front + MAXSIZE) % MAXSIZE; // 循环队列：若rear在前方，则长度为rear-front+MAXSIZE，否则为rear-front  
} 

// 获取队首元素  
DataType getFront(CirclesQueue* Q) {  
    int i;
    i = (Q -> front) %MAXSIZE;
    return Q -> data[(i + 1 % MAXSIZE)];
}
3.main.c
#include <stdio.h>
#include "CirclesQueue.h"
#include <string.h>
#include <stdlib.h>

int main(int argc, char* argv[])
{
	CirclesQueue Q;
	DataType x;
	int cmd;
	char yn;
int result;
    char welcome[] = "欢迎使用";
	int i = 0; 
	int m = 0; 
	int n = 0;
    for(i=0;i<strlen(welcome);i++)
	{
		printf("%c",welcome[i]);
		for(m=0;m<10000;m++)
			for(n=0;n<1000;n++)
			{
				;
			}
	}
	printf("\n\n\n");

	do
	{	
		printf("-----------循环队列演示-----------\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(" 0. 退出\n");
		printf(" 请选择（0~6）：");
		scanf("%d",&cmd);
		switch(cmd)
		{
		case 1:
			init(&Q);
			printf("队列已初始化！\n");
			break;
		case 2:
			printf("请输入要入队的元素x=");
			scanf("%d", &x);
			if(!enqueue(&Q,x))
			{
				printf("元素x=%d已入队\n", x);
			}
			break;
		case 3:
			printf("确定要出队（出队会将删除对首元素, y or n, n）？");
			getchar();
			scanf("%c", &yn);

			if(yn == 'y' || yn == 'Y')
			{
				if(!dequeue(&Q,&x))
				{
					printf("队首元素【%d】已出队！\n", x);
				}
			}
			break;
	    case 4:
			if(isempty(&Q)) printf("队列为空！\n");
			else printf("队列不为空！\n");
			break;
		case 5:
			if(isfull(&Q)) printf("队列已满！\n");
			else printf("队列还没有满！\n");
			break;
		case 6:
			printf("队列的长度：%d\n",getLength(&Q));
			break;
		case 7:
		    printf("队列首元素: %d\n", getFront(&Q));  
            break;
		case 8:
			printf("输出队列：");
			printQueue(&Q);
			printf("\n");
			break;
		case 9:
		    printf("本程序由邵毅豪设计开发\n");
		    break;
		}

	}while(cmd!=0);


	return 0;
}

七.小结

循环队列是一种基于数组的队列数据结构，具有以下关键特点和操作：

  1. 固定大小的数组：循环队列使用固定大小的数组来存储元素，该大小在创建队列时确定。

  2. 循环性质：队列的关键特点是它是循环的，即当"rear"指针到达数组末尾时，下一个元素将从数组的开头插入，使得队列可以循环利用数组空间，避免了数组满了之后无法插入新元素的问题。

  3. 双指针：循环队列使用两指针，"front"（前指针）和 "rear"（后指针），分别指向队列的第一个元素和最后一个元素。

  4. 高效的入队和出队操作：由于循环队列的特性，入队和出队操作通常是高效的，时间复杂度通常是O(1)。

  5. 判空和判满：可以通过指针位置的关系判断队列是否为空（"front" == "rear"）或满（("rear" + 1) % 数组大小 == "front"）。

  6. 有限大小：由于数组大小是固定的，循环队列的容量有限，因此在队列满时，无法再插入更多元素，除非出队一些元素来腾出空间。

  7. 适用场景：循环队列通常用于需要周期性循环存储数据的应用场景，如缓冲区管理、任务调度等。

  8. 需要小心管理大小和元素数量：由于容量固定，循环队列需要小心管理队列的大小和元素数量，以避免数据溢出或元素丢失的问题。

总之，循环队列是一种高效的队列数据结构，适用于需要快速入队和出队操作的情况，但要小心处理队列的大小和元素数量，以确保正常运作。

顺序循环队列的应用举例
11-12
顺序循环队列的应用举例，约瑟夫环的实现，一共有n个人，从第m个开始报数，数到x的人出队，直到所有人出队
循环队列
weixin_34360651的博客
01-27 161
循环队列类似栈，但是有两个口，一个专门用来入队，一个专门用来出队。由于入队出队不在一个端口，因此如果不适用循环队列，随着队列的使用，存储空间马上就被耗光了。在循环队列中，一个主要的知识点，就是如何判断队列为空，或者队列满。 这里主要有两个方法： 1 设置一个标记位，初始时，队列为空，我们设置flag=0;随着数据的使用，如果队满，设置flag=1; 2 使用一个空的数据位，这样rear指针永...
数据结构——循环队列
m0_74774362的博客
03-25 747
循环队列是一种基于数组的队列实现方式，它通过在数组中固定的位置上循环使用空间来实现队列的功能。循环队列有一个固定的容量，当队列满时，新元素可以覆盖掉队列头部的元素，从而实现循环利用空间。循环队列有两个指针，一个指向队列头部，一个指向队列尾部，通过这两个指针的移动，实现队列的入队和出队操作。循环队列解决了普通队列在出队操作时需要移动大量元素的问题，使得入队和出队的时间复杂度都为O(1)。
循环队列详解及队列的顺序表示和实现
08-31
循环队列是一种特殊的线性数据结构，它利用数组的“环状”特性来解决顺序队列中的“假溢出”问题。在顺序队列中，当队首和队尾指针相遇时，如果数组未满，实际上还有空间，但在逻辑上却表现为队列已满，这称为假溢出...
详解数据结构C语言实现之循环队列
09-01
循环队列是一种线性数据结构，它通过将队列的尾部与头部连接起来形成一个环状，从而克服了普通队列在满或空时可能导致的边界问题。在C语言中，实现循环队列通常涉及定义一个结构体来存储队列的属性，包括存储元素的...
数据结构详解：循环队列与链队列的原理、实现及应用场景
最新发布
03-30
内容概要：本文详细介绍了队列这一重要的数据结构，重点探讨了循环队列和链队列这两种常见实现方式。首先阐述了队列的基本概念及其在现实生活和计算机领域中的广泛应用，接着深入解析了循环队列和链队列的结构特点、...
Java循环队列原理与用法详解
08-19
Java循环队列原理与用法详解 Java循环队列是一种高效的数据结构，它可以解决顺序队列中删除队首元素时的时间复杂度O(n)问题。下面我们将详细讲解Java循环队列的原理、用法及实现。 Java循环队列的原理 在顺序队列...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值