【数据结构】队列

已于 2022-11-07 21:20:10 修改
阅读量742 收藏 9
点赞数 19
文章标签： 数据结构 c++ 链表
于 2022-08-05 14:32:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kdjjdjdjjejje128/article/details/126174582
版权
本文详细讲解了队列的基本概念，包括队列的数据结构、队列操作的函数接口，如初始化、销毁、入队、出队、判断空队及获取首尾数据。通过实例代码展示了如何利用结构体和指针实现一个简单的队列，适合初学者理解队列操作。
摘要由CSDN通过智能技术生成

上一期我们认识了栈，这一期我们来看看队列是如何实现的

文章目录

队列的概念以及结构

队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出

FIFO(First In First Out) 入队列：进行插入操作的一端称为队尾 出队列：进行删除操作的一端称为队头

用图片展示：
在这里插入图片描述

队列的实现

我们先来看一张图片：
在这里插入图片描述

队列里面的每一个数据都是结构体类型的，其中front（head）结构体指针指向队头，rear（tail）结构体指针指向队尾。

这里用不用带哨兵位是头节点都可以，我这里没有用哨兵头节点，大家像用头节点可以自己加上

1、结构体的定义

typedef int DataType;

typedef struct QueueNode//单链表的形式
{
	DataType data;//数值
	struct QueueNode* next;//指向下一个节点的指针
}QN;//重命名为QN

typedef struct Queue//定义一个结构体用来存放两个结构体指针，这样修改外面指针（也就是改变head和tail指向节点）的时候，不用传二级指针和接收改变指针的返回值
{
	QN* head;//指向队列的对头
	QN* tail;//指向队列的对尾
	int size;//记录队列数据个数，用一个计数器可以提高计算效率
}Queue;

2、函数接口声明

队列与栈的区别在于：
1、栈是：后进先出；队列是：先进先出
2、栈只能取出栈顶数据，队列可以取出队头数据和队尾数据

void QueueInit(Queue* ps);//初始化
void QueueDestroy(Queue* ps);//释放空间
bool QueueEmpty(Queue* ps);//判断队列是否为空
void QueuePush(Queue* ps,DataType x);//入队列
void QueuePop(Queue* ps);//出队列
DataType QueueFront(Queue* ps);//队头数据
DataType QueueBack(Queue* ps);//队尾数据
int QueueSize(Queue* ps);//队列剩余数据个数

3、初始化

void QueueInit(Queue* ps)//初始化
{
	assert(ps);
	ps->head = ps->tail = NULL;//两个指针都指向空
	ps->size = 0;//此时队列没有数据
}

4、销毁空间

void QueueDestroy(Queue* ps)//释放空间
{
	assert(ps);
	QN* cur = ps->head;//cur等于头指针，ps是结构体指针，结构体指针指向头指针
	while (cur)//如果头指针不为空，就进入循环释放空间
	{
		QN* del = cur;//保留头指针的节点
		cur = cur->next;//头指针向后移动
		free(del);//释放头指针移动前的节点
	}
	ps->head = ps->tail = NULL;//释放完之后，头尾指针指向NULL
	ps->size = 0;//数据个数清0
}

5、入队列

与栈同理，只有入数据才就行扩容，所以扩容不用写一个函数

void QueuePush(Queue* ps, DataType x)//入队列
{
	assert(ps);
	QN* newnode = (QN*)malloc(sizeof(QN));//扩容一个新的节点出来
	if (newnode == NULL)
	{
		perror("malloc fail\n");
		exit(-1);
	}
	else
	{
		newnode->data = x;//对新节点就行初始化操作
		newnode->next = NULL;//这里将新节点的next置空，不用考虑插入节点后的next指向了
	}
	if (ps->tail == NULL)//第一次入队列数据head和tail都是指向NULL的，直接让head和tail都指向第一个新节点
	{
		ps->head = ps->tail = newnode;
	}
	else
	{
		ps->tail->next = newnode;//将扩容节点插在tail后面
		ps->tail = newnode;//让tail指向到插入的节点处
	}
	++ps->size;//插入size就加1，记录此时队列节点的个数
}

6、出队列

void QueuePop(Queue* ps)//出队列（队列出数据就相当于单链表的头删）
{
	assert(ps);
	assert(!QueueEmpty(ps));//如果队列没有节点了，断言生效
	if(ps->head->next==NULL)//如果队列只剩下一个节点了，直接释放该节点，然后将头尾指针置空
	{
		free(ps->head);
		ps->head = ps->tail = NULL;
	}
	else
	{
		QN* cur = ps->head;//保存当前头节点
		ps->head = ps->head->next;//让头指针指向下一个节点
		free(cur);//释放之前的头节点
		cur = NULL;
	}
	--ps->size;//出一个数据size就减1
}

7、判断队列是否为空

bool QueueEmpty(Queue* ps)//判断队列是否为空
{
	assert(ps);
	return ps->head == NULL && ps->tail == NULL;//头尾指针都指向NULL，队列才为空
}

8、取出队头数据

这个很简单，下面的取出队尾数据也是

DataType QueueFront(Queue* ps)//队头数据
{
	assert(ps);
	assert(!QueueEmpty(ps));
	return ps->head->data;
}

9、取出队尾数据

DataType QueueBack(Queue* ps)//队尾数据
{
	assert(ps);
	assert(!QueueEmpty(ps));
	return ps->tail->data;
}

10、队列剩余数据个数

int QueueSize(Queue* ps)//队列剩余数据个数
{
	assert(ps);
	return ps->size;
	/*QN* cur = ps->head;//不使用size的方法，遍历队列，如果偶尔查看数据个数还好，经常使用效率太慢了
	int capacity = 0;
	while (cur)
	{
		++capacity;
		cur = cur->next;
	}
	return capacity;*/
}

全部代码

Queue.h

#pragma once

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

typedef int DataType;

typedef struct QueueNode//单链表的形式
{
	DataType data;//数值
	struct QueueNode* next;//指向下一个节点的指针
}QN;//重命名为QN

typedef struct Queue//定义一个结构体用来存放两个结构体指针
//这样修改外面指针（也就是改变head和tail指向节点）的时候，不用传二级指针和接收改变指针的返回值
{
	QN* head;//指向队列的对头
	QN* tail;//指向队列的对尾
	int size;//记录队列数据个数，用一个计数器可以提高计算效率
}Queue;

void QueueInit(Queue* ps);//初始化
void QueueDestroy(Queue* ps);//释放空间
bool QueueEmpty(Queue* ps);//判断队列是否为空
void QueuePush(Queue* ps,DataType x);//入队列
void QueuePop(Queue* ps);//出队列
DataType QueueFront(Queue* ps);//队头数据
DataType QueueBack(Queue* ps);//队尾数据
int QueueSize(Queue* ps);//队列剩余数据个数

Queue.c

#define _CRT_SECURE_NO_WARNINGS
#include"Queue.h"
void QueueInit(Queue* ps)//初始化
{
	assert(ps);
	ps->head = ps->tail = NULL;//两个指针都指向空
	ps->size = 0;//此时队列没有数据
}
void QueueDestroy(Queue* ps)//释放空间
{
	assert(ps);
	QN* cur = ps->head;//cur等于头指针，ps是结构体指针，结构体指针指向头指针
	while (cur)//如果头指针不为空，就进入循环释放空间
	{
		QN* del = cur;//保留头指针的节点
		cur = cur->next;//头指针向后移动
		free(del);//释放头指针移动前的节点
	}
	ps->head = ps->tail = NULL;//释放完之后，头尾指针指向NULL
	ps->size = 0;//数据个数清0
}
void QueuePush(Queue* ps, DataType x)//入队列
{
	assert(ps);
	QN* newnode = (QN*)malloc(sizeof(QN));//扩容一个新的节点出来
	if (newnode == NULL)
	{
		perror("malloc fail\n");
		exit(-1);
	}
	else
	{
		newnode->data = x;//对新节点就行初始化操作
		newnode->next = NULL;//这里将新节点的next置空，不用考虑插入节点后的next指向了
	}
	if (ps->tail == NULL)//第一次入队列数据head和tail都是指向NULL的，直接让head和tail都指向第一个新节点
	{
		ps->head = ps->tail = newnode;
	}
	else
	{
		ps->tail->next = newnode;//将扩容节点插在tail后面
		ps->tail = newnode;//让tail指向到插入的节点处
	}
	++ps->size;//插入size就加1，记录此时队列节点的个数
}
void QueuePop(Queue* ps)//出队列（队列出数据就相当于单链表的头删）
{
	assert(ps);
	assert(!QueueEmpty(ps));//如果队列没有节点了，断言生效
	if(ps->head->next==NULL)//如果队列只剩下一个节点了，直接释放该节点，然后将头尾指针置空
	{
		free(ps->head);
		ps->head = ps->tail = NULL;
	}
	else
	{
		QN* cur = ps->head;//保存当前头节点
		ps->head = ps->head->next;//让头指针指向下一个节点
		free(cur);//释放之前的头节点
		cur = NULL;
	}
	--ps->size;//出一个数据size就减1
}
bool QueueEmpty(Queue* ps)//判断队列是否为空
{
	assert(ps);
	return ps->head == NULL && ps->tail == NULL;//头尾指针都指向NULL，队列才为空
}
DataType QueueFront(Queue* ps)//队头数据
{
	assert(ps);
	assert(!QueueEmpty(ps));
	return ps->head->data;
}
DataType QueueBack(Queue* ps)//队尾数据
{
	assert(ps);
	assert(!QueueEmpty(ps));
	return ps->tail->data;
}
int QueueSize(Queue* ps)//队列剩余数据个数
{
	assert(ps);
	return ps->size;
	/*QN* cur = ps->head;//不使用size的方法，遍历队列，如果偶尔查看数据个数还好，经常使用效率太慢了
	int capacity = 0;
	while (cur)
	{
		++capacity;
		cur = cur->next;
	}
	return capacity;*/
}

test.c

#define _CRT_SECURE_NO_WARNINGS
#include"Queue.h"
//void Test1()
//{
//	Queue p;
//	QueueInit(&p);//初始化
//	QueuePush(&p, 1);//入队列
//	QueuePush(&p, 2);
//	QueuePush(&p, 3);
//	QueuePush(&p, 4);
//	while (!QueueEmpty(&p))
//	{
//		printf("%d ",QueueFront(&p));
//		QueuePop(&p);//出队列
//	}
//	printf("\n");
//	printf("%d ", QueueSize(&p));
//
//	QueueDestroy(&p);//释放空间
//}
void menu()
{
	printf("-----------------------------------------------\n");
	printf("***********************************************\n");
	printf("***1、入队列数据               2、出队列数据***\n");
	printf("***3、查看队列数据个数   4、判断队列是否为空***\n");
	printf("***5、提取队头数据           6、提取队尾数据***\n");
	printf("*************7、出队列打印所有数据*************\n");
	printf("***********************************************\n");
	printf("-----------------------------------------------\n");
}
int main()
{
	//Test1();
	Queue p;
	QueueInit(&p);
	int n = 0;
	int x = 0;
	do
	{
		menu();
		printf("请选择操作:");
		scanf("%d", &n);
		switch (n)
		{
		case 1:
			printf("请输入入队列数据，以-1截止:\n");
			do
			{
				scanf("%d", &x);
				//QueuePush(&p, x);
				if (x == -1)
					break;
				QueuePush(&p, x);

			} while (x != -1);
			break;
		case 2:
			QueuePop(&p);
			break;
		case 3:
			printf("%d\n", QueueSize(&p));
			break;
		case 4:
			if (QueueEmpty(&p))
			{
				printf("队列为空\n");
			}
			else
			{
				printf("队列不为空\n");
			}
			break;
		case 5:
			printf("%d\n",QueueFront(&p));
			QueuePop(&p);
			break;
		case 6:
			printf("%d\n", QueueBack(&p));
			QueuePop(&p);
			break;
		case 7:
			while (!QueueEmpty(&p))
			{
				printf("%d ", QueueFront(&p));
				QueuePop(&p);
			}
			printf("\n");
			break;
		case 0:
			QueueDestroy(&p);
			printf("退出程序\n");
			break;
		default:
			printf("操作错误，请重新选择\n");
			break;
		}
	} while (n);
	return 0;
}

总结

到这里栈和链表就结束了，如果有时间的话还会出一些栈和队列的oj题，如果没有时间的话下一期就直接进入二叉树了，又是一个难点。
那么就让我们下期见吧！

ks不知火
关注
数据结构队列用C语言描述.rar
08-07
总之，"数据结构队列用C语言描述"这个项目提供了一个学习和实践数据结构的好机会，不仅能够巩固C语言基础，还能深入理解数据结构的原理和应用。通过实际操作和调试代码，可以提升编程技能，为未来的IT职业生涯打下...
【数据结构之队列系列】队列详解
胡坚涛的博客
01-11 3945
前面我们学习了一种数据结构：栈，栈是一种只允许在一端尽进行插入删除的数据结构，而今天我们将学习另一种数据结构：队列，队列是一种支持在一端进行插入，在另一端进行删除的数据结构。
数据结构之队列
qq_53010164的博客
04-11 2370
一、队列 (1)队列的概念 队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出(FIFO)的原则。 入队列：进行插入操作的一端称为队尾 出队列：进行删除操作的一端称为对头 如图： 二、队列的实现 队列既可以用数组和也可以用链表的结构实现，使用链表的结构实现更优一些，因为如果使用数组的结构，每次删除队头，后面的元素就要向前移动，所以效率比较低 (1)问题1：结构体和指针变量传参 1.当我们创建的只是一个指针变量的时候，如果我们要改变这个指针变..
【数据结构】—— 队列
最新发布
mist的博客
08-10 1275
队列的链式存储结构，队列的顺序存储结构（循环队列）
数据结构 —— 队列（超详细图解 & 接口函数实现）
十里坡小白的博客
08-14 2708
数据结构是计算机存储、组织数据的方式。数据结构是指相互之间存在一种或多种特定关系的数据元素的集合。数据结构是一种十分优秀的解决实际问题的模板，博主将会用代码结合大量图解，对数据结构进行深度剖析。......
数据结构——队列
ttdffmm的博客
05-16 481
队列一种先进先出（FIFO）的数据结构，是一种只能在一端进行插入在另一端进行删除操作的特殊线性表。
数据结构队列
02-12
本PPT介绍了数据结构的重要的部分，队列。而队列的应用则是非常重要
经典数据结构队列的研究和实现.pdf
08-07
在数据结构的研究范畴内，队列是一种特别重要的线性数据结构，它遵循先进先出（First In First Out, FIFO）的原则。队列的概念源自日常生活中的排队等候，如商店结账或排队上公交车等。 队列的实现通常基于数组或...
数据结构队列指针操作源代码
03-24
在创建数据结构队列时，我们可能需要一个包含元素存储空间、队头和队尾指针的结构体。例如： ```c typedef struct Queue { int data[MAX_SIZE]; // 假设MAX_SIZE是队列的最大容量 int front; // 队头指针 int ...
【数据结构】队列详解
fighting小泽的博客
05-19 3096
🌸作者简介：目前正在学习C语言和数据结构。
数据结构之【队列】
weixin_40989362的博客
08-09 713
队列：先进先出，就是一块线性表，必须从头front的一方出队，从尾巴rear一方入队 我们生活中的队列就是这样的，出队的时候每次必须从a1出队，           当头出队后，尾巴就向前移动到下标为0处，这样的效率太低了，我们应该提高效率，每次头front出队了，就不需要向前移动 队头不需要每次都向前移动 如果front==rear的时候队为空，每次入队一个尾巴就向后面移动...
数据结构-队列
weixin_45666566的博客
04-18 4893
队列一.定义二.特点三.时间复杂度四.基本运算队列的顺序存储 一.定义 队列（queue）是一种先进先出的线性表，简称FIFO。在表一端（表尾）插入，在另一端（表头）删除。 二.特点 1）在表一端（表尾）插入，在另一端（表头）删除的线性表。 2）表的插入操作称为入队，表的取出操作称为出队。 3）队列的存储结构分为顺序存储或链式，存储顺序存储称为顺序队，链式存储称为链队。以循环顺序队列更常见。 4）...
数据结构韩顺平版（2）
qq_24573381的博客
04-08 280
队列 1.队列的一个使用场景 银行排队的案例: 2、队列介绍 1) 队列是一个有序列表，可以用数组或是链表来实现。 2) 遵循先入先出的原则。即：先存入队列的数据，要先取出。后存入的要后取出 3) 示意图：(使用数组模拟队列示意图) 3、数组模拟队列思路 队列本身是有序列表，若使用数组的结构来存储队列的数据，则队列数组的声明如下图, 其中 maxSize 是该队 列的最大容量。  因为队列的输出、输入是分别从前后端来处理，因此需要两个变量 front 及 ..
数据结构——队列（queue）
盛夏光年
08-02 2万+
队列（queue） 队列（queue）：只允许在一端进行插入操作，而在另一端进行删除操作的线性表。 队列是一种先进先出（First In First Out）的线性表，简称FIFO。 允许插入的一端称为队尾，允许删除的一端称为队头 1、抽象数据类型 ADT 队列(Queue) Data 同线性表。元素具有相同的类型，相邻元素具有前驱和后继关系。 Opera
【数据结构】队列(顺序队列、循环队列、链队列）
热门推荐
Jacky_Feng的博客
09-15 3万+
文章目录 前言 一、队列的定义 二、队列的顺序存储结构 1.顺序队列的定义 2.循环队列定义 3.循环队列的基本操作 三、队列的链式存储结构 1.链队列的定义 2.链队列的基本操作 前言 队列也是一种线性表，其特殊性在于队列的基本操作是线性表的子集。队列按“先进先出”的规则进行操作，故称其为操作受限的线性表。 一、队列的定义 队列（queue）是只允许在一端进行插入操作，在另一端进行删除操作的线性表，简称“队”。 队列是一种先进先出（First In First Out）的
数据结构队列看病排队
11-04
数据结构队列可以用来模拟看病排队的过程。队列是一种先进先出（FIFO）的数据结构，类似于现实生活中的排队。在看病排队的场景中，新来的病人会排在队列的末尾，而医生会从队列的头部开始依次处理病人。当一个病人被...
评论 13
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值