【数据结构初阶】队列

已于 2023-01-23 10:13:05 修改
阅读量712 收藏 2
点赞数 7
分类专栏： 数据结构 文章标签： 数据结构
于 2022-11-23 17:48:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_70811813/article/details/127992859
版权

目录

一、队列的概念和结构

二、队列的实现

        定义队列结构

        初始化队列

        销毁队列

        检测队列是否为空

        入队列 

        出队列

        获取队列头部元素 

        获取队列队尾元素 

        获取队列中有效元素个数

                优化

三、测试

 四、优化后的全部代码

一、队列的概念和结构

队列:只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出FIFO(First ln First Out)的特点

入队列:进行插入操作的一端称为队尾。

出队列:进行删除操作的一端称为队头。

就像现实生活中排队做核酸一样，从队的一段排队进入，从队的另一端做完出去：

二、队列的实现

队列也可以数组和链表的结构实现，使用链表的结构实现更优一些，因为如果使用数组的结构，无论在数组头上出数据还是在数组头上插入数据，效率都会比较低（要重新移动元素）。

        定义队列结构

在正式实现队列之前，我们先要确定队列的结构：

我们基于链表的存储结构来实现队列，所以我们队列中需要一个指向链表头的指针_front（来作为队列的队头）和一个指向链表尾部的指针_rear（来作为队列的队尾）。

//数据
typedef int QDataType;
//链表节点
typedef struct QListNode
{
	struct QListNode* _next;
	QDataType _data;
}QNode;
// 队列的结构 
typedef struct Queue
{
	QNode* _front;//队头
	QNode* _rear;//队尾
}Queue;

注：这里的对int类型进行重定义是为了我们更好的看懂QDataType只是一种数据而不仅仅是int类型。所以我们在使用队列时存储的数据并不限制于int类型，这里仅仅是举例。

        初始化队列

void QueueInit(Queue* q)
{
	assert(q);//传入的指针不能为空
	//将队头和队尾指针都初始化为空
	q->_front = NULL;
	q->_rear = NULL;
}

        销毁队列

void QueueDestroy(Queue* q)
{
	assert(q);//传入的指针不能为空
	QNode* cur = q->_front;
	//释放链表空间
	while (cur)
	{
		QNode* del = cur;
		cur = cur->_next;
		free(del);
	}
	//将队头和队尾指针置空(防止野指针的产生)
	q->_front = q->_rear = NULL;
}

        检测队列是否为空

bool QueueEmpty(Queue* q)
{
	assert(q);//传入的指针不能为空
	return q->_front == NULL && q->_rear == NULL;//如果队头队尾指针都为空返回的就是真值
}

        入队列 

void QueuePush(Queue* q, QDataType data)
{
	assert(q);//传入的指针不能为空
	QNode* newnode = (QNode*)malloc(sizeof(QNode));//为新元素开辟空间
	if (newnode == NULL)//判断是否开辟成功
	{
		perror("malloc");
		exit(-1);
	}
	newnode->_data = data;
	newnode->_next = NULL;
	//注意这里尾插时要判断队中是否为空，是空的话需要改变队头和队尾指针的指向
	if (QueueEmpty(q))
	{
		q->_front = q->_rear = newnode;
	}
	else
	{
		q->_rear->_next = newnode;
		q->_rear = q->_rear->_next;
	}
}

        出队列

void QueuePop(Queue* q)
{
	assert(q);//传入的指针不能为空
	assert(!QueueEmpty(q));//队列不能为空
	QNode* del = q->_front;
	//注意这里尾插时要判断队中是否为空，如果是的话需要将队头队尾指针置为空
	if (q->_front == q->_rear)
	{
		q->_front = q->_rear = NULL;
	}
	else
	{
		q->_front = q->_front->_next;
	}
	free(del);//释放节点空间
}

        获取队列头部元素 

QDataType QueueFront(Queue* q)
{
	assert(q);//传入的指针不能为空
	assert(!QueueEmpty(q));//队列不能为空
	return q->_front->_data;//返回队列头部元素
}

        获取队列队尾元素 

QDataType QueueBack(Queue* q)
{
	assert(q);//传入的指针不能为空
	assert(!QueueEmpty(q));//队列不能为空
	return q->_rear->_data;//返回队列队尾元素
}

        获取队列中有效元素个数

int QueueSize(Queue* q)
{
	assert(q);//传入的指针不能为空
	int size = 0;
	QNode* cur = q->_front;
	//遍历累计节点总个数
	while (cur)
	{
		cur = cur->_next;
		size++;
	}
	return size;//返回累计的个数
}

直到这里所以的函数的时间复杂度都是O(1)，只有获取队列中有效元素个数（QueueSize）函数的时间复杂度为O(n)，我们可以稍微改变一下队列的结构来优化一下算法，使QueueSize函数的时间复杂度变为O(1)：

                优化

将队列结构加上一个记录节点总数的变量:

//数据
typedef int QDataType;
//链表节点
typedef struct QListNode
{
	struct QListNode* _next;
	QDataType _data;
}QNode;
// 队列的结构 
typedef struct Queue
{
	QNode* _front;//队头
	QNode* _rear;//队尾
    int size;//记录节点总数
}Queue;

初始化队列时要将size变量置为0：

void QueueInit(Queue* q)
{
	assert(q);//传入的指针不能为空
	//将队头和队尾指针都初始化为空
	q->_front = NULL;
	q->_rear = NULL;
	q->size = 0;//置0
}

在每次入队列时，将size变量加1：

void QueuePush(Queue* q, QDataType data)
{
	assert(q);//传入的指针不能为空
	QNode* newnode = (QNode*)malloc(sizeof(QNode));//为新元素开辟空间
	if (newnode == NULL)//判断是否开辟成功
	{
		perror("malloc");
		exit(-1);
	}
	newnode->_data = data;
	newnode->_next = NULL;
	//注意这里尾插时要判断队中是否为空，是空的话需要改变队头和队尾指针的指向
	if (QueueEmpty(q))
	{
		q->_front = q->_rear = newnode;
	}
	else
	{
		q->_rear->_next = newnode;
		q->_rear = q->_rear->_next;
	}
	q->size++;//加1
}

在每次出队列时，将size变量减1：

void QueuePop(Queue* q)
{
	assert(q);//传入的指针不能为空
	assert(!QueueEmpty(q));//队列不能为空
	QNode* del = q->_front;
	//注意这里尾插时要判断队中是否为空，如果是的话需要将队头队尾指针置为空
	if (q->_front == q->_rear)
	{
		q->_front = q->_rear = NULL;
	}
	else
	{
		q->_front = q->_front->_next;
	}
	free(del);//释放节点空间
	q->size--;//减1
}

销毁队列时记得将size变量置为0：

void QueueDestroy(Queue* q)
{
	assert(q);//传入的指针不能为空
	QNode* cur = q->_front;
	//释放链表空间
	while (cur)
	{
		QNode* del = cur;
		cur = cur->_next;
		free(del);
	}
	//将队头和队尾指针置空(防止野指针的产生)
	q->_front = q->_rear = NULL;
	q->size = 0;//置0
}

这样QueueSize函数的时间复杂度就能优化为O(1)了：

int QueueSize(Queue* q)
{
	assert(q);//传入的指针不能为空
	return q->size;//返回累计的个数
}

三、测试

测试代码：

void Test()
{
	Queue q;
	QueueInit(&q);
	printf("队列中有效元素个数为：%d\n", QueueSize(&q));
	QueuePush(&q, 1);
	printf("队列中有效元素个数为：%d 队列头部元素为：%d 队列队尾元素为：%d\n", QueueSize(&q), QueueFront(&q), QueueBack(&q));
	QueuePush(&q, 2);
	printf("队列中有效元素个数为：%d 队列头部元素为：%d 队列队尾元素为：%d\n", QueueSize(&q), QueueFront(&q), QueueBack(&q));
	QueuePush(&q, 3);
	printf("队列中有效元素个数为：%d 队列头部元素为：%d 队列队尾元素为：%d\n", QueueSize(&q), QueueFront(&q), QueueBack(&q));
	QueuePush(&q, 4);
	printf("队列中有效元素个数为：%d 队列头部元素为：%d 队列队尾元素为：%d\n", QueueSize(&q), QueueFront(&q), QueueBack(&q));
	QueuePop(&q);
	printf("队列中有效元素个数为：%d 队列头部元素为：%d 队列队尾元素为：%d\n", QueueSize(&q), QueueFront(&q), QueueBack(&q));
	QueuePop(&q);
	printf("队列中有效元素个数为：%d 队列头部元素为：%d 队列队尾元素为：%d\n", QueueSize(&q), QueueFront(&q), QueueBack(&q));
	QueuePush(&q, 5);
	printf("队列中有效元素个数为：%d 队列头部元素为：%d 队列队尾元素为：%d\n", QueueSize(&q), QueueFront(&q), QueueBack(&q));
	QueueDestroy(&q);
	printf("队列中有效元素个数为：%d\n", QueueSize(&q));
}

测试效果：

 四、优化后的全部代码

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>
//数据
typedef int QDataType;
//链表节点
typedef struct QListNode
{
	struct QListNode* _next;
	QDataType _data;
}QNode;
// 队列的结构 
typedef struct Queue
{
	QNode* _front;//队头
	QNode* _rear;//队尾
	int size;//记录节点总数
}Queue;

// 初始化队列 
void QueueInit(Queue* q)
{
	assert(q);//传入的指针不能为空
	//将队头和队尾指针都初始化为空
	q->_front = NULL;
	q->_rear = NULL;
	q->size = 0;//置0
}
// 检测队列是否为空
bool QueueEmpty(Queue* q)
{
	assert(q);//传入的指针不能为空
	return q->_front == NULL && q->_rear == NULL;//如果队头队尾指针都为空返回的就是真值
}
// 队尾入队列 
void QueuePush(Queue* q, QDataType data)
{
	assert(q);//传入的指针不能为空
	QNode* newnode = (QNode*)malloc(sizeof(QNode));//为新元素开辟空间
	if (newnode == NULL)//判断是否开辟成功
	{
		perror("malloc");
		exit(-1);
	}
	newnode->_data = data;
	newnode->_next = NULL;
	//注意这里尾插时要判断队中是否为空，是空的话需要改变队头和队尾指针的指向
	if (QueueEmpty(q))
	{
		q->_front = q->_rear = newnode;
	}
	else
	{
		q->_rear->_next = newnode;
		q->_rear = q->_rear->_next;
	}
	q->size++;//加1
}
// 队头出队列 
void QueuePop(Queue* q)
{
	assert(q);//传入的指针不能为空
	assert(!QueueEmpty(q));//队列不能为空
	QNode* del = q->_front;
	//注意这里尾插时要判断队中是否为空，如果是的话需要将队头队尾指针置为空
	if (q->_front == q->_rear)
	{
		q->_front = q->_rear = NULL;
	}
	else
	{
		q->_front = q->_front->_next;
	}
	free(del);//释放节点空间
	q->size--;//减1
}
// 获取队列头部元素 
QDataType QueueFront(Queue* q)
{
	assert(q);//传入的指针不能为空
	assert(!QueueEmpty(q));//队列不能为空
	return q->_front->_data;//返回队列头部元素
}
// 获取队列队尾元素 
QDataType QueueBack(Queue* q)
{
	assert(q);//传入的指针不能为空
	assert(!QueueEmpty(q));//队列不能为空
	return q->_rear->_data;//返回队列队尾元素
}
// 获取队列中有效元素个数 
int QueueSize(Queue* q)
{
	assert(q);//传入的指针不能为空
	return q->size;//返回累计的个数
}
// 销毁队列 
void QueueDestroy(Queue* q)
{
	assert(q);//传入的指针不能为空
	QNode* cur = q->_front;
	//释放链表空间
	while (cur)
	{
		QNode* del = cur;
		cur = cur->_next;
		free(del);
	}
	//将队头和队尾指针置空(防止野指针的产生)
	q->_front = q->_rear = NULL;
	q->size = 0;//置0
}

本期博客到这里就结束了，代码量较多如有纰漏还请各位大佬不吝赐教！

谢谢各位看客的支持，我们下期见~

1e-12
关注
专栏目录
《数据结构初阶》用队列实现栈&&用栈实现队列的细致解析
m0_62171658的博客
03-29 4138
《数据结构初阶》用队列实现栈&&用栈实现队列的细致解析
初阶数据结构+高阶数据结构，分别用c、c++来实现.zip
10-23
本资料包"初阶数据结构+高阶数据结构，分别用c、c++来实现.zip"包含了使用C和C++语言实现的数据结构实例，旨在帮助初学者和进阶者深化对数据结构的理解。 首先，让我们从初阶数据结构开始。基础的数据结构通常包括...
数据结构之队列（Queue）
m0_58761900的博客
07-11 1530
栈的定义：队列是一种特殊的线性表，它只允许在一端进行插入（队尾）数据操作，在另一端进行删除（队头）数据操作。 队列具有先进先出的特点 队列的实现也是有两种方式 数组实现，链表实现 双端队列（Deque）是指在两端都可以进行入队和出队的操作的队列 不过需要注意的是，不能将一个数据，在一端进行入队和出队操作，不然这样就成了栈 ...
【数据结构】队列（队列的出入，有效元素，判空，获取队头，队尾元素）
金金金金金的博客
03-19 6139
//队列的声明 #pragma once typedef int QDataType; typedef struct QNode{ struct QNode* next; QDataType val; }QNode; typedef struct Queue{ struct QNode* head; struct QNode* rear; QDataT...
循环队列的实现（初始化、入队操作、出队操作、判满、判空、获取队头、队尾元素、销毁操作）
weixin_46153828的博客
03-15 3461
typedef struct { int* array; int front; int rear; int count; //用count++的方式判断循环队列是否满 int N; //总个数 } MyCircularQueue; //初始化 MyCircularQueue* myCircularQueueCreate(int k) { MyCircularQueue* myQueue=(MyCircularQueue*)malloc(sizeof(MyCircu...
【数据结构】队列
kdjjdjdjjejje128的博客
08-05 742
队列
c语言中如何取代队尾元素,数据结构——队列的详解
weixin_36130575的博客
05-22 502
上一篇博客：数据结构——栈的详解文章目录队列的定义C语言中的队列队列的基本操作队列的初始化入队出队求队列中的元素的个数取队头元素C语言实现队列的具体代码C++中的队列队列的初始化入队返回对列中的第一个元素返回队列中的最后一个元素出队判断队列是否为空求队列中元素的个数C++实现队列的完整代码队列的定义队列和栈相反，队列(queue)是一种先进先出(FIFO:first in first out)的线...
数据结构初阶数据结构初阶
最新发布
02-12
初学者在学习数据结构时，通常会遇到一系列基础概念和重要类型，这些都会在"数据结构初阶"的学习中逐步揭示。 首先，我们要理解数据结构的基本概念。数据结构是存储和组织数据的一种方式，它不仅考虑了数据的存储，...
C语言实现数据结构算法初阶算法
06-15
5. **队列**：队列是一种先进先出（FIFO）的数据结构，适用于任务调度和消息传递。C语言中，队列可由数组（循环队列）或链表实现，常用的操作有enqueue（入队）和dequeue（出队）。 6. **二叉树遍历**：二叉树是一...
STL笔记总结-queue
m0_66484415的博客
02-06 899
1.queue的定义 要使用queue，应先添加头文件#include<queue>。 queue<typename>name; 2.queue容器内元素的访问 由于队列（queue）本身就是一种先进先出的限制性数据结构，因此在STL中只能通过front（）来访问队首元素， 或是通过back（）来访问队尾元素。 queue<int>q; for(int i=1;i<=5;i++) q.push(i); printf("%d %d\n",q.front(),q.bac
队列的基本操作（C语言链表实现）初始化，入队，出队，销毁，读取数据
m0_74774759的博客
04-22 1938
提示：以下是本篇文章正文内容，下面案例可供参考队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出FIFO(First In First Out) 入队列：进行插入操作的一端称为队尾出队列：进行删除操作的一端称为队头队列也可以数组和链表的结构实现，使用链表的结构实现更优一些，因为如果使用数组的结构，出队列在数组头上出数据，效率会比较低。
队列的存入和取出
2303_76653912的博客
08-23 150
2、队尾：允许插入的一端称为队尾，通常用一个尾指针（rear）的指针指向队尾元素，即 尾指针总是指向最后被插入的元素。Step3：然后在将排头指针指向位置的后一个位置的元素赋给指定的变量。当队尾指针=数组的最大容量-1时，队列已满，不能进行入队运算。3、队头：允许删除的一端称为队头，通常用一个排头指针指向排头元素的前一个位置。1、队列：队列是允许在一端进行插入、而在另一端进行删除的线性表。//初始化队列数组。
数据结构期末复习资料
热门推荐
ao_mike的博客
06-05 1万+
单选 2x10 判断 1x10 应用题 50分 算法题 10 + 10分 选择题 1. 算法的计算量的大小称为计算的（）。 A．效率B. 复杂性C. 现实性D. 难度 2. 算法的时间复杂度取决于（） A．问题的规模B. 待处理数据的初态C. A和B 3.计算机算法指的是（1），它必须具备（2）这三个特性。 (1) A．计算方法B. 排序方法C. 解决问题的...
栈、队列、优先队列
qq_55819440的博客
04-10 163
一、STL提供了三种特殊的数据结构:栈、队列、优先队列 栈 ： 头文件： < stack > 用stack< int >s 去定义： C++ Stack（堆栈） 是一个容器类的改编，为程序员提供了堆栈的全部功能，——也就是说实现了一个先进后出（FILO）的数据结构。。 符合先进后出 函数: empty() 堆栈为空则返回真 pop() 移除栈顶元素 push() 在栈顶增加元素 size() 返回栈中元素数目 top() 返回栈顶元素
数据结构——循环队列（数组实现）
m0_63020222的博客
03-22 3196
循环队列的数组实现及基本操作
数据结构之循环队列基本操作(c语言）
weixin_46364710的博客
04-16 9910
队列： 队列是一种先进先出(First In First Out)的线性表。它只允许在表的一端进行插入，在另一端删除元素。 允许插入的一端成为队尾，允许删除的一端成为队头 循环队列的顺序表示和实现： 队列有顺序表示和链式表示两种方式，我们此处用顺序表示 队列的顺序存储结构： #define MAXSIZE 10 typedef struct{ ElemType *base; //存储空间基地址(数组首地址） int front; //队头 int rear; .
java中队列中最后一个元素,Java基础系列26：有关队列的经典题目解析与代码实现...
weixin_36373860的博客
03-10 1025
package cn.zifangsky.queue.questions;import org.junit.Test;import cn.zifangsky.queue.LinkQueue;import cn.zifangsky.queue.Queue;import cn.zifangsky.stack.Stack;/*** 如何使用两个队列来实现一个栈？** @author zifangsky*...
循环队列和链式队列的结构及其基本操作（入队、出队、取队头、查看对内元素）
Fizz_沫烨的博客
01-23 9612
循环队列 队列：只允许在一端进行插入操作，在另一端进行删除操作；数据存储在一个一维数组中 特点：先进先出（FIFO）结构 队头（front）：删除数据的一端 队尾（rear）：插入数据的一端 顺序队列的缺点：空队时front和rear都指向下标-1处，进队时rear先+1，再放入数据，出队时front先+1，再删数据 队满时一个个删数据，当front和rear都指向最后的位置时，前面的
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

1e-12

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

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

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

打赏作者

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

抵扣说明：

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

余额充值