队列（基于数组实现和链表实现）和循环队列

最新推荐文章于 2024-08-01 12:59:57 发布
最新推荐文章于 2024-08-01 12:59:57 发布
阅读量372 收藏 2
点赞数
分类专栏： 数据结构与算法（C语言） 文章标签： 队列 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40496794/article/details/108277645
版权

在这里插入图片描述

一、基于数组实现的队列

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

#define size 10  // 宏定义一个大小为10的队列

// 基于数组实现的队列称为顺序队列
// 定义一个队列的数组结构体
typedef struct queue
{
	int data[size];  // 利用数组实现队列元素的定位
	int head;  // 队头下标
	int tail;  // 队尾下标
}Array_queue;

// 建立一个空队列
Array_queue * Create_queue()
{
	// 申请空间
	Array_queue* q = (Array_queue*)malloc(sizeof(Array_queue));
	if (q == NULL)
	{
		return 0;
	}
	q->head = q->tail = 0;  // 队头和队尾下标都初始化为0
	return q;
}

// 入队
void enqueue(Array_queue* q, int x)
{
	// q->tail = size表示队末没有空间了
	if (q->tail == size)
	{
		// 若队列前面有空余空间，则将队内所有元素往前移
		for (int i = q->head; i < q->tail; i++)
		{
			q->data[i - q->head] = q->data[i];  
		}
		// 搬移完后更新队头和队尾指针
		q->tail -= q->head;
		q->head = 0;
	}
	q->data[q->tail] = x;
	q->tail++;
}

// 出队（队内元素索引出队） 
void dequeue(Array_queue* q, int x)  // 传入队内元素并使其出队
{
	while (x != q->data[q->head])  // 移动队头指针
	{
		q->head++;
	}
	q->head++; 
}

// 打印队列
void Print_queue(Array_queue* q)
{
	int i = q->head;  // 从队头开始打印
	while (i != q->tail)
	{
		printf("%d ", q->data[i]);
		i++;
	}
	printf("\n");
}

int main()
{
	int j = 10;
	Array_queue* q = Create_queue();
	printf("开始入队：\n");
	while (j--)
	{
		// 在进行入队之前加个判断，看队列是否已满，防止数组溢出
		if ((q->head == 0) && (q->tail == size))
		{
			printf("队列已满！\n");
			break;
		}
		enqueue(q, 10 - j);  // 入队
		printf("%d入队后，队内元素为：", 10 - j);
		Print_queue(q);
	}
	dequeue(q, 5);  // 出队
	printf("元素5出队后，队内元素为：");
	Print_queue(q);  // 打印队列
	puts("队列末尾已经无空间，再次执行入队操作时，需将队内元素整体往前移");
	puts("使队头指针重新初始化为0");
	// 重新执行入队操作
	enqueue(q, 110);
	printf("元素110入队后，队内元素为：");
	Print_queue(q);
	printf("队尾还剩4个数据空间\n");
	return 0;
}

运行结果：
在这里插入图片描述

基于数组实现的队列在进行入队操作时，需要警惕的一点就是数组溢出问题，因为基于数组实现的队列是通过下标的移动来进行的，当队列满了之后，队尾指针已经达到数组的最大值，这时就需要进行数据的迁移，若队头前面还有剩余空间，则将队列元素整体往前移，让队头下标重新置为0，否则重新申请一块更大的数组空间来存放队列。

二、基于链表实现的队列

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

//基于链表实现的队列称为链式队列
// 定义队列结点
typedef struct Node  
{
	int data;  // 元素
	struct Node* next;
}Node;

// 定义队列的结构体
typedef struct LinkList_queue
{
	Node* head;  // 队头指针
	Node* tail;  // 队尾指针
}LinkList_queue;

LinkList_queue * Create_queue()
{
	// 申请空间
	LinkList_queue* q = (LinkList_queue*)malloc(sizeof(LinkList_queue));
	if (q == NULL)
	{
		return;
	}
	q->head = q->tail = NULL;  // 将队头队尾初始化为NULL
	return q;  // 返回q
}

// 入队
void enqueue(LinkList_queue* q, int x)
{
	Node* p = (Node*)malloc(sizeof(Node));  // 申请一个结点空间
	p->data = x;  // 往结点内传值
	p->next = NULL;  // 结点的next设为NULL
	if ((q->tail == NULL) && (q->head == NULL))  // 判断队头和队尾是否为空，用于第一次入队
	{
		q->head = p;  // 队头和队尾都要指向p结点
		q->tail = p;
	}
	else
	{
		q->tail->next = p;  // 让p成为当前尾部的下一结点
		q->tail = p;  // 尾部指针指向p
		// 队头和队尾通过p结点相连，在内存空间地址上是相同的
		// 我们只需要移动队尾结点，使其指向队尾元素即可
	}
	
}

// 出队 按元素来索引出队
void dequeue(LinkList_queue* q, int x)
{
	if (q->head == NULL)  // 判断队列是否为空
	{
		return;
	}
	else
	{
		// 移动队头指针
		while (q->head->data != x)
		{
			q->head = q->head->next;
		}
		q->head = q->head->next;  // 只移动队头指针，不移动队尾指针
		// 如果q->head == NULL说明队列已经被清空，若此时想要再重新入队
		// 则根据前面入队的代码需将q->tail重新置为空
		if (q->head == NULL)  
		{
			q->tail = NULL;
		}
		// 出队时，若队列未清空，则不涉及队尾指针的修改
	}
}

void Print_queue(LinkList_queue* q)
{
	Node* p = (Node*)malloc(sizeof(Node));  // 申请一个结点空间
	p = q->head;
	if (q->head == NULL)  // 如果队列为空
	{
		printf("队列已经被清空！");
	}
	while (p != NULL)
	{
		printf("%d ", p->data);
		p = p->next;
	}
	printf("\n");
}

int main()
{
	int i = 5;
	LinkList_queue* q = Create_queue();  // 先创建一个空队列
	printf("开始入队：\n");
	while (i--)
	{
		enqueue(q, 5 - i);  // 进队
		printf("%d入队后，队内元素为：", 5 - i);
		Print_queue(q);  // 打印队列
	}
	enqueue(q, 6);
	printf("6入队后，队内元素为：");
	Print_queue(q);
	dequeue(q, 4);  // 出队
	printf("元素4出队后，队内元素为：");
	Print_queue(q);  // 打印队列
	dequeue(q, 6);  // 出队
	printf("元素6出队后，队内元素为：");
	Print_queue(q);  // 打印队列
	// 重新执行入队操作
	enqueue(q, 7);
	printf("元素7入队后，队内元素为：");
	Print_queue(q);  // 打印队列
	dequeue(q, 7);  // 出队
	printf("元素7出队后，队内元素为：");
	Print_queue(q);  // 打印队列
	free(q);  // 养成好习惯，清空q，防止内存溢出
	return 0;
}

运行结果：
在这里插入图片描述

基于链表实现的队列没有空间限制，出队即删除元素，无法找回，只能重新入队。

三、循环队列

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

#define size 5  // 宏定义一个大小为5的队列

// 定义一个队列的数组结构体
typedef struct queue
{
	int data[size];  // 储存队列元素
	int head;  // 队头下标
	int tail;  // 队尾下标
	int n;  // 记录队列容量
}Loop_queue;

// 建立一个空队列
Loop_queue* Create_queue()
{
	// 申请空间
	Loop_queue* q = (Loop_queue*)malloc(sizeof(Loop_queue));
	if (q == NULL)
	{
		return 0;
	}
	q->head = q->tail = q->n = 0;  // 队头和队尾下标都初始化为0
	return q;
}

// 入队
void enqueue(Loop_queue* q, int x)
{
	if (((q->tail + 1) % size) == q->head)  // 判断队列是否已满
	{
		// if(ture) 说明队列已满，使队列容量+1
		// 用于跳出主函数的循环并打印队列已满的提示
		q->n++;
	}
	else
	{
		q->data[q->tail] = x;
		/*循环队列入队操作的核心代码*/
		q->tail = (q->tail + 1) % size;
		q->n++;  // 每入一次队就使队列容量+1
	}
}

// 出队(按元素索引出队)
void* dequeue(Loop_queue* q, int x)
{
	while (x--)
	{
		/*循环队列出队操作的核心代码*/
		q->head = (q->head + 1) % size;
		// 每出一次队，就让队列的容量-1
		q->n--;
	}

}

// 打印队列
void Print_queue(Loop_queue* q)
{
	int i = q->head; // 从队头开始打印
	int j = q->n;
	if (q->head == q->tail)
	{
		printf("队列为空，无法执行出队操作！");
	}
	else if (q->head == size - 1)
	{
		printf("队列已经被清空！");
		q->head = q->tail = q->n = 0;  // 队头和队尾下标以及队列容量都初始化为0
	}
	else
	{
		while (j--)
		{
			if (i < size)
			{
				printf("%d ", q->data[i]);
				i++;
			}
			else
			{
				printf("%d ", q->data[i - size]);
				i++;
			}
		}
	}
	printf("\n");
}

int main()
{
	int j = 5;
	Loop_queue* q = Create_queue();
	puts("***循环队列***");
	puts("开始入队：");
	while (j--)
	{
		enqueue(q, 5 - j);  // 入队
		// 入队后判断队列是否已满
		if ((q->n % size) == q->head)  // 易错点：q->tail从入队函数出来后已经是4了
		{
			printf("队列已满！请等待队首元素出队后再执行入队操作\n");
			q->n -= 1;  // 使队列容量恢复回正常值
			break;
		}
		printf("%d入队后，队内元素为：", 5 - j);
		Print_queue(q);
	}
	dequeue(q, 3);
	printf("元素3出队后，队内元素为：");
	Print_queue(q);  // 打印队列
	enqueue(q, 5);
	printf("元素5入队后，队内元素为：");
	Print_queue(q);
	enqueue(q, 6);
	printf("元素6入队后，队内元素为：");
	Print_queue(q);
	dequeue(q, 6);
	printf("元素6出队后，队内元素为：");
	Print_queue(q);  // 打印队列
	free(q);
	return 0;
}

运行结果：
在这里插入图片描述

1.循环队列操作要点

  • 循环队列需要额外定义一个变量来记录队列的大小
  • 队头指针（head）和队尾指针（tail）以及队列大小都初始化为0，队列每增加一个元素就+1，每减少一个元素就-1
  • 入队操作核心代码：tail = (tail + 1) % size，size是队列的大小
  • 出队操作核心代码：head = (head + 1) % size
  • 队满条件：head == tail
  • 队空条件：(tail + 1) % n = head
  • 队满与队空的条件一定要分析好，否则程序可能会运行出错！！！

2.运行结果的判断

  • 看队首和队尾元素是否都能出队？
  • 队首元素出队后是否能继续入队？
  • 是否能持续进行出队和入队操作？
  • 队满和队空的时候是否能给出提示？

3.循环队列特点：

(1)与<顺序队列>相比，循环队列在进行数据的搬移时更加地自然，不需要重新申请一个额外的存储空间；
(2)由于入队操作的的原因，当队满时，队尾指针指向的位置实际上并没有数据，所以循环队列会浪费一个存储空间；

一溢孤行
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
队列的数组实现与链表实现
扭轱辘旋转的博客
06-07 6042
队列的说明 队列是一种基本的数据结构。我们平时排队等候服务的时候，是先到的人先接受服务。对于队列这种数据结构，实现的就是一种先进先出（first-int, first-out, FIFO）的策略。 改变队列中元素的操作方法只有两个——push与pop。push是把元素从队尾插入，pop是把元素从队头删除。 数组实现 队列的数组实现有两种形式，一种是线性实现，另一种是
循环队列详解及队列的顺序表示和实现
08-31
需要注意的是，循环队列必须预先设定最大队列长度`MAX_QUEUE_SIZE`，并且在无法预估所需最大长度的情况下，可能需要使用链表来实现更灵活的动态增长。代码中提供的实现使用了一个固定大小的数组来存储队列元素，适用...
队列（数组实现和链表实现）
beichengll的博客
07-16 1279
1.概念：具有一定操作约束的线性表 2.特点：（1）只能在一端插入（入队），另一端删除（出队）。 （2）.先进先出。 3.存储实现方式：数组、链表。 4.基本操作： 1.数组实现（循环数组）： 注意：（1）、普通的顺序存储的数组用来实现队列时，存在一个问题：当rear（记录队尾的变量）到达maxsize-1时，不能确定队列是否满，因为前面可能
数据结构：队列，数组实现、链表实现和循环队列
luoyeyeyu的专栏
10-12 1060
  一、什么是队列：         一种先进先出的数据结构（FIFO结构）。新元素添加在队尾（push），删除操作删掉第一个元素（pop）二、队列的实现方式：         队列的实现方式数组实现、链表实现三、常见的队列：         常用队列循环队列、阻塞队列、并发队列 四、怎么实现一个无BUG的队列思考        思考1：head（头元素）和tail（尾元素）的初始值 ...
数据结构之优先队列（线性结构的优先队列，数组实现和链表实现）
lspdd的博客
02-06 1956
优先队列(priority queue) 普通的队列是一种先进先出的数据结构，元素在队列尾追加，而从队列头删除。在优先队列中，元素被赋予优先级。当访问元素时，具有最高优先级的元素最先删除。优先队列具有最高级先出 （first in, largest out）的行为特征 优先队列是0个或多个元素的集合,每个元素都有一个优先权或值,对优先队列执行的操作有1) 查找;2) 插入一个新元素;3) 删除.在最小优先队列(min priority queue)中,查找操作用来搜索优先权最小的元素,删除操作用来删除该元素
队列的实现：数组实现和链表实现
monkeyzh123的专栏
07-27 556
队列：一种先进先出的线性表（FIFO） 本文分别用链表和数组实现了队列，包括创建，出队，入队操作，以及如何使用
6、链表和数组，哪个实现队列更快？
天界程序员的博客
11-05 925
数据结构的选择，要比算法优化更重要要有时间复杂度的敏感性，如length不能遍历查找。
基于数组和链表Java底层实现Queue队列和循环队列
曲怪曲怪
02-20 472
Queue 队列 文章目录1、什么是队列2、Queue数据结构实现——基于动态数组2.1、基本函数实现2.2 进出队列函数2.3 查询操作3、Queue数据结构实现——基于链表函数3.1、基本函数实现3.2 进出队列函数3.3 查询操作4、LoopQueue循环队列的实现4.1、基本函数实现4.2、进出队列函数4.3、查询操作5、时间复杂度分析最后 1、什么是队列 同 Stack 一...
Java 数据结构篇-用链表、数组实现队列（数组实现：循环队列）_java queue数组实现
2401_84301315的博客
05-16 281
对于从来没有接触过网络安全的同学，我们帮你准备了详细的学习成长路线图。可以说是最科学最系统的学习路线，大家跟着这个大的方向学习准没问题。因篇幅有限，仅展示部分资料。
阻塞队列BlockingQueue数组和链表的实现
binga的博客
11-05 571
目录阻塞队列抽象接口BlockingQueue数组阻塞队列ArrayBlockingQueue链表阻塞队列LinkedBlockingQueue 在并发多线程之Lock及ReentrantLock源码剖析中了解了独占锁的实现ReentrantLock及Condition的原理和使用，接下来就来了解一下基于ReentrantLock和Condition实现的阻塞队列，本篇主要讲解的是数组和链表实现阻塞队列。首先队列的特性大家都知道是“先进先出”，那么实现先进先出的队列数据结构可以使用数组或者链表，链表一般能都
循环队列的数组实现方式与链表实现方式
单线程的Daniel的博客
12-27 531
假设front指向队列的头部，rear指向队列的尾部。 则队列满的条件是：(rear+1)%QueueSize==front 则队列为空的条件为：rear==front 通用的计算队列长度的公式：(rear-front+QueueSize)%QueueSize 则队列的数组实现如下： private int[] array; private int front; private int rea...
Python-数组实现循环队列和非循环队列
12-22
根据实现方式，队列可以分为循环队列和非循环队列。 1. **非循环队列**： 非循环队列的实现通常使用数组或链表。在这个例子中，我们看到一个基于数组的非循环队列类`Queue`。该类有以下方法： - `__init__(self, ...
数组和链表实现队列
10-21
由于数组的固定大小，如果队列已满，需要考虑循环队列的概念，即队列的前后端相遇后继续在原地覆盖旧元素。 3. **出队操作**：出队时，移除队首元素，并将队首指针向后移动一位。若队首指针等于队尾指针，表示队列为...
C语言数组-C语言实现使用静态数组实现循环队列.zip
03-02
综上所述，通过C语言中的静态数组实现循环队列，我们能够创建一个既能存储多个元素，又能灵活处理满队和空队情况的数据结构。这不仅有助于提高程序的效率，还能降低内存管理的复杂性。通过学习和实践，我们可以...
详解数据结构C语言实现之循环队列
09-01
在C语言中，实现循环队列通常涉及定义一个结构体来存储队列的属性，包括存储元素的数组、队头指针`front`、队尾指针`rear`以及队列的最大容量`maxsize`。 1. 循环队列基础： - 参数：循环队列需要两个关键参数，即...
数据结构(面试)
Anterior_condyle的博客
08-01 1025
在含有n个带权叶节点的二叉树中，其中带权路径（WPL）最小的二叉树称为哈夫曼树，也称最优二叉树。
2024.7.24 作业
qq_64434282的博客
07-24 3058
【代码】2024.7.24 作业。
数理方法习题 前六章.pdf
08-03
数理方法习题 前六章
某大型制造企业IT蓝图规划及实施路线.pptx
最新发布
08-03
某大型制造企业IT蓝图规划及实施路线.pptx
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值