循环队列--队列的顺序表示和实现（固定存储空间和可增存储空间两种）（第三章 P63）

最新推荐文章于 2023-10-28 20:53:29 发布
原创 最新推荐文章于 2023-10-28 20:53:29 发布 · 2.1k 阅读 · 16 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#c语言 #数据结构
本文详细介绍了循环队列的存储结构与基本操作，包括初始化、销毁、清空、判断空满、获取队头、队列遍历、入队和出队等，并通过实例演示了循环队列在动态调整存储空间时的处理方法。

循环队列--队列的顺序表示和实现

 

定义队列顺序存储结构，在元素出队时，只是改变指针的位置，不移动元素，可简化操作，节约时间。但这样的话，队列的每个存储空间自始至终只能存储一个队列元素。即使这个队列元素出队后，其他的队列元素也不能占用这个存储空间。这样存储空间浪费较大。因此，考虑使用循环队列。

将顺序队列臆造为一个环状的空间，当队尾元素占据了存储空间的最后一个单元，如再有元素入队，不是申请新的存储空间，而是将新元素插入到存储空间的第一个单元，只要这个单元为空（元素已出队）。

 

在循环队列中，队尾指针可能小于队头指针。元素入队时，队尾指针加 1 。当队列满时，队尾指针等于队头指针，和队列空时的条件一样。为了区别队满和队空，在循环队列中，少用一个存储单元。

也就是在存储空间为 MAX_QSIZE 的循环队列中，最多只能存放 MAX_QSIZE-1 个元素。这样，队列空的条件仍为队尾指针等于队头指针，队列满的条件改为 (队尾指针+1)对 MAX_QSIZE 求余等于队头指针 。

 

 

 

 
 
 
 
 

typedef int Status; /* Status是函数的类型,其值是函数结果状态代码，如OK等 */
typedef int Boolean; /* Boolean是布尔类型,其值是TRUE或FALSE */
typedef int QElemType; /* 定义队列元素的类型 */

#include<malloc.h> /* malloc()等 */
#include<stdio.h> /* EOF(=^Z或F6),NULL */
#include<process.h> /* exit() */

/* 函数结果状态代码 */
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2 


/* --------------------------   队列的顺序存储结构  -----------------------------*/

#define MAXQSIZE 5 /* 最大队列长度(对于循环队列，最大队列长度要减1) */
typedef struct
{
	QElemType *base; /* 初始化的动态分配存储空间 */
	int front; /* 头指针,若队列不空,指向队列头元素 */
	int rear; /* 尾指针,若队列不空,指向队列尾元素的下一个位置 */
}SqQueue;

/* ----------------------------------------------------------------------------*/


void visit(QElemType i)
{
	printf("%d ", i);
}



/*  循环队列的基本操作(9个) */

/* --------------------        基本操作的函数原型说明     ---------------------*/
Status InitQueue(SqQueue *Q);
Status DestroyQueue(SqQueue *Q);
Status ClearQueue(SqQueue *Q);
Status QueueEmpty(SqQueue Q);
int QueueLength(SqQueue Q);
Status GetHead(SqQueue Q, QElemType *e);
Status EnQueue(SqQueue *Q, QElemType e);
Status DeQueue(SqQueue *Q, QElemType *e);
Status QueueTraverse(SqQueue Q, void(*vi)(QElemType));


/* ---------------------------------             基本操作的实现         ------------------------------------*/


Status InitQueue(SqQueue *Q)
{ /* 构造一个空队列Q */
	(*Q).base = (QElemType *)malloc(MAXQSIZE * sizeof(QElemType));
	if (!(*Q).base) /* 存储分配失败 */
		exit(OVERFLOW);
	(*Q).front = (*Q).rear = 0;
	return OK;
}

Status DestroyQueue(SqQueue *Q)
{ /* 销毁队列Q,Q不再存在 */
	if ((*Q).base)
		free((*Q).base);
	(*Q).base = NULL;
	(*Q).front = (*Q).rear = 0;
	return OK;
}

Status ClearQueue(SqQueue *Q)
{ /* 将Q清为空队列 */
	(*Q).front = (*Q).rear = 0;
	return OK;
}

Status QueueEmpty(SqQueue Q)
{ /* 若队列Q为空队列,则返回TRUE,否则返回FALSE */
	if (Q.front == Q.rear) /* 队列空的标志 */
		return TRUE;
	else
		return FALSE;
}

int QueueLength(SqQueue Q)
{ /* 返回Q的元素个数,即队列的长度 */
	return(Q.rear - Q.front + MAXQSIZE) % MAXQSIZE;
}

Status GetHead(SqQueue Q, QElemType *e)
{ /* 若队列不空,则用e返回Q的队头元素,并返回OK,否则返回ERROR */
	if (Q.front == Q.rear) /* 队列空 */
		return ERROR;
	*e = *(Q.base + Q.front);
	return OK;
}

Status EnQueue(SqQueue *Q, QElemType e)
{ /* 插入元素e为Q的新的队尾元素 */
	if (((*Q).rear + 1) % MAXQSIZE == (*Q).front) /* 队列满 */
		return ERROR;
	(*Q).base[(*Q).rear] = e;
	(*Q).rear = ((*Q).rear + 1) % MAXQSIZE;
	return OK;
}

Status DeQueue(SqQueue *Q, QElemType *e)
{ /* 若队列不空,则删除Q的队头元素,用e返回其值,并返回OK;否则返回ERROR */
	if ((*Q).front == (*Q).rear) /* 队列空 */
		return ERROR;
	*e = (*Q).base[(*Q).front];
	(*Q).front = ((*Q).front + 1) % MAXQSIZE;
	return OK;
}

Status QueueTraverse(SqQueue Q, void(*vi)(QElemType))
{ /* 从队头到队尾依次对队列Q中每个元素调用函数vi().一旦vi失败,则操作失败 */
	int i;
	i = Q.front;
	while (i != Q.rear)
	{
		vi(*(Q.base + i));
		i = (i + 1) % MAXQSIZE;
	}
	printf("\n");
	return OK;
}



/*  检验以上操作的主程序 */

void main()
{
	Status j;
	int i = 0, l;
	QElemType d;
	SqQueue Q;
	InitQueue(&Q);
	printf("初始化队列后，队列空否？%u(1:空 0:否)\n", QueueEmpty(Q));
	printf("请输入整型队列元素(不超过%d个),-1为提前结束符: ", MAXQSIZE - 1);
	do
	{
		scanf_s("%d", &d);
		if (d == -1)
			break;
		i++;
		EnQueue(&Q, d);
	} while (i < MAXQSIZE - 1);
	printf("队列长度为: %d\n", QueueLength(Q));
	printf("现在队列空否？%u(1:空 0:否)\n", QueueEmpty(Q));
	printf("连续%d次由队头删除元素,队尾插入元素:\n", MAXQSIZE);
	for (l = 1; l <= MAXQSIZE; l++)
	{
		DeQueue(&Q, &d);
		printf("删除的元素是%d,请输入待插入的元素: ", d);
		scanf_s("%d", &d);
		EnQueue(&Q, d);
	}
	l = QueueLength(Q);
	printf("现在队列中的元素为: \n");
	QueueTraverse(Q, visit);
	printf("共向队尾插入了%d个元素\n", i + MAXQSIZE);
	if (l - 2 > 0)
		printf("现在由队头删除%d个元素:\n", l - 2);
	while (QueueLength(Q) > 2)
	{
		DeQueue(&Q, &d);
		printf("删除的元素值为%d\n", d);
	}
	j = GetHead(Q, &d);
	if (j)
		printf("现在队头元素为: %d\n", d);
	ClearQueue(&Q);
	printf("清空队列后, 队列空否？%u(1:空 0:否)\n", QueueEmpty(Q));
	DestroyQueue(&Q);
}

运行结果：

 

 

以上程序所采用的循环队列存储结构，当队列长度大于 MAX_QSIZE - 1 时，无法动态地增加存储空间。为了使循环队列也能动态地增加存储空间，下面程序不固定队列长度，把队列长度也作为结构体的一个成员。

 


typedef int Status; /* Status是函数的类型,其值是函数结果状态代码，如OK等 */
typedef int Boolean; /* Boolean是布尔类型,其值是TRUE或FALSE */
typedef int QElemType; /* 定义队列元素的类型 */

#include<malloc.h> /* malloc()等 */
#include<stdio.h> /* EOF(=^Z或F6),NULL */
#include<process.h> /* exit() */

/* 函数结果状态代码 */
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2 


/* --------------------------   队列的顺序存储结构  -----------------------------*/

#define QUEUE_INIT_SIZE 5 /* 存储空间初始分配量 */
#define QUEUE_INCREMENT 2 /* 存储空间分配增量 */

typedef struct
{
	QElemType *base; /* 初始化的动态分配存储空间 */
	int front; /* 头指针,若队列不空,指向队列头元素 */
	int rear; /* 尾指针,若队列不空,指向队列尾元素的下一个位置 */
	int queuesize; //队列的长度
}SqQueue;

/* ----------------------------------------------------------------------------*/

void print(QElemType i)
{
	printf("%d ", i);
}


/*  循环队列的基本操作(9个) */

/* --------------------        基本操作的函数原型说明     ---------------------*/

int QueueLength(SqQueue Q);
void EnQueue(SqQueue *Q, QElemType e);
Status DeQueue(SqQueue *Q, QElemType *e);
void QueueTraverse(SqQueue Q, void(*vi)(QElemType));
Status InitQueue(SqQueue *Q);
Status DestroyQueue(SqQueue *Q);
Status ClearQueue(SqQueue *Q);
Status QueueEmpty(SqQueue Q);
Status GetHead(SqQueue Q, QElemType *e);


/* ---------------------------------             基本操作的实现         ------------------------------------*/

int QueueLength(SqQueue Q)
{ // 返回Q的元素个数，即队列的长度
	return(Q.rear - Q.front + Q.queuesize) % Q.queuesize;
}

void EnQueue(SqQueue *Q, QElemType e)
{ // 插入元素e为Q的新的队尾元素
	int i;
	if (((*Q).rear + 1) % (*Q).queuesize == (*Q).front)
	{ // 队列满，增加存储单元
		(*Q).base = (QElemType *)realloc((*Q).base, ((*Q).queuesize + QUEUE_INCREMENT) * sizeof(QElemType));
		if (!(*Q).base) // 增加单元失败
			exit(ERROR);
		if ((*Q).front > (*Q).rear) // 形成循环
		{
				for (i = (*Q).queuesize - 1; i >= (*Q).front; i--)
					(*Q).base[i + QUEUE_INCREMENT] = (*Q).base[i]; // 移动高端元素到新的高端
				(*Q).front += QUEUE_INCREMENT; // 移动队头指针
		}
		(*Q).queuesize += QUEUE_INCREMENT; // 增加队列长度
	}
	(*Q).base[(*Q).rear] = e; // 将e插入队尾
	(*Q).rear = ++(*Q).rear% (*Q).queuesize; // 移动队尾指针
}

Status DeQueue(SqQueue *Q, QElemType *e)
{ // 若队列不空，则删除Q的队头元素，用e返回其值，并返回OK；否则返回ERROR(见图337)
	if ((*Q).front == (*Q).rear) // 队列空
		return ERROR;
	*e = (*Q).base[(*Q).front]; // 用e返回队头元素
	(*Q).front = ++(*Q).front% (*Q).queuesize; // 移动队头指针
	return OK;
}

void QueueTraverse(SqQueue Q, void(*vi)(QElemType))
{ // 从队头到队尾依次对队列Q中每个元素调用函数vi()
	int i = Q.front; // i指向队头
	while (i != Q.rear) // 没到队尾
	{
		vi(Q.base[i]); // 调用函数vi()
		i = ++i % Q.queuesize; // 向后移动i指针
	}
		printf("\n");
}


Status InitQueue(SqQueue *Q)
{ /* 构造一个空队列Q */
	(*Q).base = (QElemType *)malloc(QUEUE_INIT_SIZE * sizeof(QElemType));
	if (!(*Q).base) /* 存储分配失败 */
		exit(OVERFLOW);
	(*Q).front = (*Q).rear = 0;
	(*Q).queuesize = QUEUE_INIT_SIZE;
	return OK;
}

Status DestroyQueue(SqQueue *Q)
{ /* 销毁队列Q,Q不再存在 */
	if ((*Q).base)
		free((*Q).base);
	(*Q).base = NULL;
	(*Q).front = (*Q).rear = 0;
	(*Q).queuesize = 0;
	return OK;
}

Status ClearQueue(SqQueue *Q)
{ /* 将Q清为空队列 */
	(*Q).front = (*Q).rear = 0;
	return OK;
}

Status QueueEmpty(SqQueue Q)
{ /* 若队列Q为空队列,则返回TRUE,否则返回FALSE */
	if (Q.front == Q.rear) /* 队列空的标志 */
		return TRUE;
	else
		return FALSE;
}

Status GetHead(SqQueue Q, QElemType *e)
{ /* 若队列不空,则用e返回Q的队头元素,并返回OK,否则返回ERROR */
	if (Q.front == Q.rear) /* 队列空 */
		return ERROR;
	*e = *(Q.base + Q.front);
	return OK;
}





/*  检验以上操作的主程序 */

void main()
{
	Status j;
	int i, n = 6;
	QElemType d;
	SqQueue Q;
	InitQueue(&Q);
	printf("初始化队列后，队列空否？%u(1:空 0:否)\n", QueueEmpty(Q));
	printf("队列长度为%d\n", QueueLength(Q));
	printf("请输入%d个整型队列元素:\n", n);
	for (i = 0; i < n; i++)
	{
		scanf("%d", &d);
		EnQueue(&Q, d);
	}
	printf("队列长度为%d\n", QueueLength(Q));
	printf("现在队列空否？%u(1:空 0:否)\n", QueueEmpty(Q));
	printf("现在队列中的元素为 \n");
	QueueTraverse(Q, print);
	for (i = 1; i <= 3; i++)
		DeQueue(&Q, &d);
	printf("由队头删除3个元素，最后删除的元素为%d\n", d);
	printf("现在队列中的元素为 \n");
	QueueTraverse(Q, print);
	j = GetHead(Q, &d);
	if (j)
		printf("队头元素为%d\n", d);
	else
		printf("无队头元素(空队列)\n");
	for (i = 1; i <= 5; i++)
		EnQueue(&Q, i);
	printf("依次向队尾插入1～5，现在队列中的元素为\n");
	QueueTraverse(Q, print);
	ClearQueue(&Q);
	printf("清空队列后, 队列空否？%u(1:空 0:否)\n", QueueEmpty(Q));
	j = GetHead(Q, &d);
	if (j)
		printf("队头元素为 %d\n", d);
	else
		printf("无队头元素(空队列)\n");
	DestroyQueue(&Q);
}

运行结果：

 

数据结构—队列的顺序表示和实现--循环队列
小虾米编程
07-03 1854
和顺序栈相类似，在队列的顺序存储结构中，除了用一组地址连续的存储单元依次存放从队列头到队列尾的元素之外，尚需附设两个整型变量 front和rear分别指示队列头元素及队列尾元素 1.队列的顺序表示 typedef struct { int *base; // 分配存储空间 int front; // 队头指针 int rear; // 队尾指针 }SqQueue; ...
队列之循环队列详解（C语言版）
热门推荐
qq_44075108的博客
02-15 3万+
本篇文章详细的介绍了数据结构队列中的循环队列，并用C语言对其常用操作进行了实现。
算法与数据结构之循环队列
谁D了我的BUG
01-25 580
为什么静态队列必须是循环队列？ 静态队列也就是用数组实现的队列，在非空队列中，头指针指向队头元素，尾指针指向队列尾元素的下一个位置，对于非循环队列来说，假设为队列分配的最大空间为6，当尾指针指向第7个元素的位置时，不可再继续插入新的队尾元素，否则会因数组越界而导致程序代码被破坏，而此时又不宜如顺序栈那样，进行存储再分配扩大数组空间。因为队列的实际可用空间并未占满，一个巧妙的方法是将顺序队列臆造为一...
循环队列----队列的顺序表示和实现
Bee_Darker的博客
10-26 3054
1.队列的顺序表示 1）C语言的描述 初始化建空对列时，令front=rear=0,每当插入新的队尾元素时，“尾指针增1”；每当删除队列头元素时，“头指针增1”。因此，在非空队列中，头指针始终指向队列头元素，而尾指针始终指向队列尾元素的下一位置，如图所示。 2）存在问题 假设当前为队列分配的最大空间为6，则当队列处于图3.12（d）的状态时不可再继续插入新的队尾元素，否则会因数组越界而...
一篇文章讲清楚循环队列——循环队列是什么？有什么应用场景？怎么实现？
qq_42186650的博客
08-21 6655
相比于链队列，循环队列有着内存固定，效率高等特点，因而广泛应用于计算机的各个层面。本文主要介绍循环队列的概念，列举一些循环队列的应用场景，以及给出用数组实现循环队列的代码。本文介绍了循环队列的定义、使用场景和实现方式。大家可能疑问，为什么上边举例的场景不用链队列实现？比如用链队列实现流水线缓存，IO缓存等。我觉得是这样的：链队列一般是用于队列大小不固定的场景，而且依赖于操作系统给它分配资源。而流水线缓存，IO缓存等过于底层的东西，是比操作系统还底层的东西，我们难以给他们动态调度资源。
数据结构篇——队列
y805805的博客
02-28 219
队列的定义 是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。与栈相反，队列是 一种先进先出（First In First Out，FIFO）的线性表。 队列的链式存储结构 #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; typedef int ElemType; typedef struct Node{ ElemType d...
数据结构第十篇——顺序队列
weixin_30920513的博客
10-02 117
和栈相反，队列（queue）是一种先进先出（First In First Out,FIFO）的线性表。它只允许在表的一端进行插入，而在另一端删除元素、这和我们日常生活中的排队是一致的，最早进入队列的元素最早离开。在队列中，允许插入的一端叫做队尾(rear)，允许删除的一端称为队头(front)。 队列在程序设计中也经常出现。一个最典型的例子就是操作系统中的作业排队。 在允许多道程序运行的计算机...
习题总结007
qq_43410906的博客
03-27 1634
1.定义了一维 int 型数组 a[10] 后，下面错误的引用是（ C ） A.a[0] = 1; B.a[0] = 5*2; C.a[10] = 2; D.a[1] = a[2] * a[0]; 解析：数组的角标是从0开始的，一维数组中一共10个元素，所以最后一个元素的角标应该是9。 2.一维数组与线性表的区别是( A )。 A.前者长度固定,后者长度可变 B.后者...
习题整理1.15、16、17
aaacome的博客
01-18 1415
10.任何一个带权的无向连通图的最小生成树（ ）。 解析：如果无向图中有一条边的权值为负数那么算法在运行是因为是贪心算法，所以会造成生成树不存在的情况。 如果图中的所有节点之间的权值都相同，而且每个节点都有到其他节点的边，那么生成的最小生成树不就有很多。 11.在jdk 1.7中，以下说法正确的是（ ）。 解析：这题纯粹是想考察JDB1.8和1.9的接口新特性（因为其提到JDK1.7） 1.8接口可以定义default方法和static方法；1.9接口中可以定义私有方法。 因此在JD
队列文档之循环队列
二木成林
05-09 8910
循环队列就是将顺序队列臆造成一个环状的空间（实际上不是，只是把它看成是环状的），即把存储队列元素的顺序表从逻辑上视为一个环。
数据结构——队列（1）
qq_43441284的博客
11-09 642
队列是限制在两端进行插入操作和删除操作的线性表存入删除。
数据结构笔记6 递归；队列
m0_49372475的博客
07-05 769
栈与递归：分治法求解递归问题算法的一般形式，递归函数调用 队列：顺序表示和实现，队列的链式存储和实现
循环队列（顺序表示和实现）
weixin_47700137的博客
07-21 804
队列有两种存储表示，顺序表示和链式表示。 98 和顺序栈相类似，在队列的顺序存储结构中，除了用一组地址连续的存储单元依次存放从队列头到队列尾的元素之外，尚需附设两个整型变量front和rear分别指向队列头元素和队列尾元素的位置（即称为头指针和尾指针）。 为了在C语言中描述方便起见，在此约定：初始化创建空队列时，令front=rear=0，每当插入新的队列尾元素时，尾指针rear增1：每当删除队列头元素时，头指针front增1。因此，在非空队列中，头指针始终指向队列头元素，而尾指针始终指向队列尾元素的下一个
循环队列详解
qq_31186123的博客
10-07 2756
前面分析顺序队的时候,我们知道,顺序队存在”假溢出”的问题,这个问题有时会造成很大的内存浪费,循环队列就是为了解决这个问题而提出地一个很巧妙的办法.循环队列和顺序队列的主要区别在于:循环队列将顺序队列臆造成一个环状空间.在操作上这种异同体现在: 相同点: 在顺序队列和循环队列中,进行出队、入队操作时,队首、队尾指针都要加 1 ,朝前移动。 不同点: 1. 在循环队列中当队首、队尾指针指向向...
详解循环队列
m0_72158882的博客
10-28 967
循环队列是一种数据结构，它可以在有限的存储空间内实现队列的操作。循环队列通常用数组实现，并且有一个固定的大小。它有两个指针，一个是头指针（front），另一个是尾指针（rear）。在循环队列中，当尾指针到达数组的末端，如果队列仍未满，它会从数组的开始位置继续。循环队列中的元素可以按照先进先出（FIFO）的顺序进行操作。具体来说，插入元素的操作（通常称为入队）发生在rear指针指向的位置，而删除元素的操作（通常称为出队）发生在front指针指向的位置。当rear指针追上front指针时，队列为空；
队列: 尾指针索引小于头指针的扩容问题
duoduo1636546的博客
09-29 654
  队列，一种作为构思算法的辅助数据结构，和栈相反，遵循FIFO即先进先出原则。   为了节省空间，提高底层数据结构的使用率(队列可以通过数组实现，也可以通过链表实现)，常见的做法和其他数据结构扩容不同，并不是尾指针移至末尾就进行扩容，而是将尾指针移至0，从头开始(当然这要求底层数据结构如数组，起始的位置数据已经pop出去了，否则将进行扩容)。如下所示:   如图我们再次pop一个3的时候...
数据结构——循环队列与链队列
Acc222222的博客
08-08 2643
1.循环队列
（四）数据结构-队列
weixin_45579930的博客
07-21 719
双端队列是指允许两端都可以进行入队和出队操作的队列，其元素的额逻辑结构仍然是线性结构将队列的两端分别称为前端和后端，两端都可以入队和出队。
队列的存储和循环队列
kxbdys的博客
04-22 2697
一、队列的存储结构 1、队列的物理存储可以用顺序存储结构，也可用链式存储结构。相应队列的存储方式也分为两种，即顺序队列和链式队列。 2、顺序队列可以用一维数组表示如下： #define MAXQSIZE 100 //最大队列长度 Typedef struct { QElemType *base; //初始化的动态分配存储空间 int front; //头指针 int rear； //尾指针 }SqQueue; 二、循环队列的基本操作语句 1、队列的初始：front=rear=0; 2、
【数据结构】循环队列的实现
记录学习点滴
08-24 5471
>✨给大家推荐一款很火爆的刷题、面试求职网站✨
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

想去的远方

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值