数据结构-队列

最新推荐文章于 2025-04-23 14:30:00 发布
最新推荐文章于 2025-04-23 14:30:00 发布
阅读量689 收藏 13
点赞数 13
分类专栏： C语言 数据结构 知识 文章标签： 数据结构 c语言 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2302_81301620/article/details/147323993
版权

大家好，上期介绍了数据结构-栈的内容，这期咱们接着来看看数据结构中-队列的内容，一起来看看吧！！！

1.队列的概念

1.1队列的含义

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

  • 入队列：进行插入操作的一端称为队尾
  • 出队列：进行删除操作的一端称为队头
    在这里插入图片描述

类比成一个隧道：先进去的车先出来，隧道入口叫做队尾，隧道出口叫做队头。车从队尾进入隧道就是入队列，车从队头出隧道就是出队列。
在这里插入图片描述

1.2队列与栈的区别

入栈顺序：1 出栈顺序：N 1对多
入队列：1 出队列：1 1对1

应用：
1.买奶茶
买奶茶排队问题：就相当于一个队列，先预定的人先排在队列中，一定先得到奶茶，保证公平性；
如何知道前面还有多少号呢？取队头数据，把你两的号一减就知道了还有几个人轮到自己。

2.广度优先遍历
好友推荐问题：qq系统会根据共同好友给用户推荐可能认识的人，这里就涉及到先推荐谁的问题，当然是与用户联系程度高的好友。
在这里插入图片描述
比如，我们要找小徐的好友的好友，该怎么办呢?
先把小徐入队列，再出队列，小徐的好友：小明和小王入队列，此时，队列里是小徐的好友；我们再分别把小明和小王出队列，他们两的好友入队列，那么此时，队列里的就是小徐的好友的好友啦！先进先出

2.队列的实现

2.1实现思路

队列也可以数组和链表的结构实现，使用链表的结构实现更优一些，因为如果使用数组的结构，出队列在数组头上出数据，效率会比较低。
需要在一端入数据，另一端出数据，因此首先排除数组。使用单链表即可。

在这里插入图片描述
在这里插入图片描述

//初始化
void QueueInit(Queue* pq);
//队尾插入
//void QueuePush(QNode**phead,QNode**ptail,int x);
void QueuePush(Queue* pq, QDataType x);
//队头删除
void QueuePop(Queue* pq);
// 获取队列头部元素
QDataType QueueFront(Queue* pq);
// 获取队列队尾元素
QDataType QueueBack(Queue* pq);
// 获取队列中有效元素个数
int QueueSize(Queue* pq);
// 检测队列是否为空，如果为空返回非零结果，如果非空返回0
bool QueueEmpty(Queue* pq);
// 销毁队列
void QueueDestroy(Queue* pq);

2.2定义节点

  1. 我们用链表实现队列，链表是由一个个节点组成的，因此我们需要定义节点的结构，这里用结构体指针。
  2. 一个节点是由数据和指向下一个节点的指针组成。
    清楚这两点，我们就很快写出来了。
    在这里插入图片描述
#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include<assert.h>
//用单链表实现队列
typedef int QDataType;
//定义节点
typedef struct QueueNode
{
	struct QueueNode* next;
	QDataType val;
}QNode;

2.3初始化

队列：先进先出，也叫尾插头出，进出顺序是唯一的。
为了方便后续操作，我们需要使用两个指针，头指针和尾指针。

参数传递原则：在C++中，参数传递是值传递的，直接修改形参不会改变实参。但是，可以通过二级指针修改形参指针指向的内容，因为二级指针指向的内容就是一个一级指针。

因此，我们若想要通过修改形参来改变实参，值传递是不行的，得用二级指针修改形参指针指向的内容。即：

//队尾插入
//void QueuePush(QNode**phead,QNode**ptail,int x);

这里我们可以在定义一个节点的结构体指针，存放头尾两个节点指针，既方便书写，也避免使用二级指针，简化了代码。即：

//再定义一个结构体指针，放头尾节点指针
typedef struct Queue
{
	QNode* phead;
	QNode* ptail;
	int size;
}Queue;

//队尾插入
//void QueuePush(QNode**phead,QNode**ptail,int x);
void QueuePush(Queue* pq, QDataType x);

//初始化
void QueueInit(Queue* pq)
{
	assert(pq);
	pq->phead = NULL;
	pq->ptail = NULL;
	pq->size = 0;
}

2.4队尾插入

队列是用链表实现的，而链表是由节点组成的，因此在插入之前得先为节点开辟内存malloc。并检查内存是否开辟成功，成功后，则开始插入。

  • 动态申请新节点内存: malloc,申请完检查是否成功
  • 初始化新节点：新节点是队尾，所以next指向NULL;数据x
  • 将新节点插入队尾：考虑队列是否为空
  • 更新队列大小：pq->size++
//队尾插入
void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);

	//动态申请新节点内存
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)//检查内存分配是否成功
	{
		perror("malloc fail!");
		return;
	}
	//初始化新节点
	newnode->next = NULL;//新节点是队尾，所以next是NULL
	newnode->val = x;

	//将新节点插入队尾
	if (pq->ptail == NULL)//情况①：队列为空（phead 和 ptail 都为 NULL）
	{
		//队列为空
		pq->phead = pq->ptail = newnode; 新节点既是头也是尾
	}
	else
	{
		//队列不为空
		pq->ptail->next = newnode;//原队尾的next指向新节点
		pq->ptail = newnode;//更新ptail指向新队尾
	}
	pq->size++;//更新队列大小
}

2.5队头删除

队头删除，不单单是简单的free，将指针置空，还需要考虑只有一个节点的情况，这也往往是容易出错忘记的地方。
在这里插入图片描述

//队头删除
void QueuePop(Queue* pq)
{
	assert(pq);
	assert(pq->size!=0);

	//只有一个节点
	if (pq->phead->next == NULL)
	{
		free(pq->phead);
		pq->phead = pq->ptail = NULL;
	}
	else//多个节点
	{
		QNode* next = pq->phead->next;
		free(pq->phead);
		pq->phead = next;
	}
	pq->size--;
}

2.6获取队头元素

// 获取队列头部元素
QDataType QueueFront(Queue* pq)
{
	assert(pq);
	assert(pq->phead);

	return pq->phead->val;
}

2.7获取队尾元素

// 获取队列队尾元素
QDataType QueueBack(Queue* pq)
{
	assert(pq);
	assert(pq->ptail);

	return pq->ptail->val;
}

2.8获取有效元素个数

// 获取队列中有效元素个数
int QueueSize(Queue* pq)
{
	assert(pq);

	return pq->size;
}

2.9判空

// 检测队列是否为空，如果为空返回非零结果，如果非空返回0
bool QueueEmpty(Queue* pq)
{
	assert(pq);

	return pq->size == 0;
}

2.10销毁队列

在这里插入图片描述

  • 队列是由链表实现的，链表是由节点组成的，故销毁队列就是释放所有节点。
  • 遍历队列，逐个释放节点。
  • 从头节点开始，为防止改变头节点，我们新定义一个指针cur
  • 循环遍历所有节点，直到cur为NULL,即遍历完整个队列。
  • 必须先保存下一个节点，才能释放当前节点，否则后续无法访问。
  • 释放完一个节点，移动cur到下一个节点next，继续上述操作。
  • 释放完要重置队列状态
//销毁队列
void QueueDestroy(Queue* pq)
{
	assert(pq);  // 确保队列指针有效

	// 1. 遍历队列，逐个释放节点
	QNode* cur = pq->phead;  // 从头节点开始
	while (cur != NULL)      // 遍历直到队尾
	{
		QNode* next = cur->next;  // 先保存下一个节点
		free(cur);                // 释放当前节点
		cur = next;               // 移动到下一个节点
	}

	// 2. 重置队列状态
	pq->phead = NULL;  // 头指针置空
	pq->ptail = NULL;  // 尾指针置空
	pq->size = 0;      // 队列大小归零
}

2.11测试

在这里插入图片描述
在这里插入图片描述

3.完整代码

3.1 Queue.h

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


//用单链表实现队列

typedef int QDataType;
//定义节点
typedef struct QueueNode
{
	struct QueueNode* next;
	QDataType val;
}QNode;

//再定义一个结构体指针，放头尾节点指针
typedef struct Queue
{
	QNode* phead;
	QNode* ptail;
	int size;
}Queue;

//初始化
void QueueInit(Queue* pq);
//队尾插入
//void QueuePush(QNode**phead,QNode**ptail,int x);
void QueuePush(Queue* pq, QDataType x);
//队头删除
void QueuePop(Queue* pq);
// 获取队列头部元素
QDataType QueueFront(Queue* pq);
// 获取队列队尾元素
QDataType QueueBack(Queue* pq);
// 获取队列中有效元素个数
int QueueSize(Queue* pq);
// 检测队列是否为空，如果为空返回非零结果，如果非空返回0
bool QueueEmpty(Queue* pq);
// 销毁队列
void QueueDestroy(Queue* pq);

3.2 Queue.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"Queue.h"

//初始化
void QueueInit(Queue* pq)
{
	assert(pq);
	pq->phead = NULL;
	pq->ptail = NULL;
	pq->size = 0;
}
//队尾插入
void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);

	//动态申请新节点内存
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)//检查内存分配是否成功
	{
		perror("malloc fail!");
		return;
	}
	//初始化新节点
	newnode->next = NULL;//新节点是队尾，所以next是NULL
	newnode->val = x;

	//将新节点插入队尾
	if (pq->ptail == NULL)//情况①：队列为空（phead 和 ptail 都为 NULL）
	{
		//队列为空
		pq->phead = pq->ptail = newnode; 新节点既是头也是尾
	}
	else
	{
		//队列不为空
		pq->ptail->next = newnode;//原队尾的next指向新节点
		pq->ptail = newnode;//更新ptail指向新队尾
	}
	pq->size++;//更新队列大小
}

//队头删除
void QueuePop(Queue* pq)
{
	assert(pq);
	assert(pq->size!=0);

	//只有一个节点
	if (pq->phead->next == NULL)
	{
		free(pq->phead);
		pq->phead = pq->ptail = NULL;
	}
	else//多个节点
	{
		QNode* next = pq->phead->next;
		free(pq->phead);
		pq->phead = next;
	}
	pq->size--;

}

// 获取队列头部元素
QDataType QueueFront(Queue* pq)
{
	assert(pq);
	assert(pq->phead);

	return pq->phead->val;
}
// 获取队列队尾元素
QDataType QueueBack(Queue* pq)
{
	assert(pq);
	assert(pq->ptail);

	return pq->ptail->val;
}
// 获取队列中有效元素个数
int QueueSize(Queue* pq)
{
	assert(pq);

	return pq->size;
}
// 检测队列是否为空，如果为空返回非零结果，如果非空返回0
bool QueueEmpty(Queue* pq)
{
	assert(pq);

	return pq->size == 0;
}

//销毁队列
void QueueDestroy(Queue* pq)
{
	assert(pq);  // 确保队列指针有效

	// 1. 遍历队列，逐个释放节点
	QNode* cur = pq->phead;  // 从头节点开始
	while (cur != NULL)      // 遍历直到队尾
	{
		QNode* next = cur->next;  // 先保存下一个节点
		free(cur);                // 释放当前节点
		cur = next;               // 移动到下一个节点
	}

	// 2. 重置队列状态
	pq->phead = NULL;  // 头指针置空
	pq->ptail = NULL;  // 尾指针置空
	pq->size = 0;      // 队列大小归零
}

3.3 test.c

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include<assert.h>

#include"Queue.h"

int main()
{
	Queue q;

	QueueInit(&q);
	QueuePush(&q, 1);
	QueuePush(&q, 2);
	QueuePush(&q, 3);
	QueuePush(&q, 4);

	//访问队列所有元素
	while (!QueueEmpty(&q))
	{
		printf("%d ", QueueFront(&q));
		QueuePop(&q);
	}
	printf("\n");
	return 0;
}
数据结构---队列及其应用
CS专业追想日记
10-08 1632
实验目录一、实验目的二、实验内容三、实验步骤四、实验代码一、队列的定义二、算法的初始化和实现五、总结 一、实验目的 1.掌握队列的基本概念、基本操作和基本使用方式。 2.掌握循环队列的类型定义以及实现方法。 3.掌握循环队列的基本操作:初始化、入队、出队、队空判断、获取队头元素。 4.掌握循环队列的实现和简单应用。 5.能够清楚理解循环队列中空间的重用思想。 二、实验内容 1.设计和实现一个队列数据结构,且采用循环队列实现方法。 2.实现循环队列的各种操作,包括循环队列的初始化、出入队、清空和释放等。 3.
4.C-数据结构-队列
09-15
队列是一种先进先出（First In First Out，FIFO）的数据结构，它有两个主要操作：入队（enqueue），即将一个数据项添加到队列末尾；以及出队（dequeue），即移除队列前端的数据项。队列适用于多种计算场景，如任务...
数据结构与算法-头歌【4】循环队列--课上练
m0_61804419的博客
03-19 1452
数据结构与算法-头歌【4】循环队列--课上练
头歌队列——课上练
m0_62901089的博客
10-03 1413
【代码】头歌队列——课上练。
Java数据结构-队列
Vampire的博客
04-04 3273
队列，循环队列
数据结构-队列【小白指南，超详细】
dawn_007_seven的博客
12-08 2044
本文主要讲述队列的各个详细步骤，从如何创建、各种功能、测试功能，对代码进行分析，逐代码分析，超级详细拆解队列，以及各种注意事项。最后还有源代码，方便大家去调试、测试!
Educoder头歌数据结构-队列基本运算的实现及其应用
qq_50848214的博客
11-05 9892
**头歌实践平台答案educoder ** 数据结构-队列基本运算的实现及其应用 第1关：顺序队列的实现 /************************************************************* date: January 2019 循环顺序队列 实现文件 **************************************************************/ void SQ_In(SqQueue *Q, ElemType e) /
【头歌】数据结构-队列的应用
wx_15774293141的博客
05-25 8809
任务描述本关任务：编写一个循环队列，实现入队、出队操作，判断队空、队满等特殊情况。相关知识为了完成本关任务，你需要掌握：1.循环队列定义，2.入队、出队的定义，3.队空、队满的情况。循环队列定义循环队列将数组存储区看成是一个首尾相接的环形区域（下图）。当数据存放到尾地址后，下一个地址就跳转到首地址。循环队列定义如下：入队出队定义入队操作：队列未满，在队尾插入一个元素item，使得，若超过存储空间则尾指针索引取模；出队操作：队列不空，返回队首元素值，并移除队首元素front+1。
C语言数据结构-队列
Flin
03-13 2976
队列的特征： 特殊的线性表，先进先出(FIFO) (1)数据：对于非空的队列，表头没有直接前驱，表尾没有直接后继，其他有且仅有一个直接前驱和一个直接后继。 (2)操作：只允许在表尾插入数据，在表头删除数据 ...
数据结构-队列（Queue）
热门推荐
修心
01-22 2万+
队列（Queue）   队列的基本概念   定义   队列（Queue）。队列简称队。是一种操作受限的线性表，只允许在表的一端进行插入，而在表的另一端进行删除。向队列中插入元素称为入队或进队；删除元素称为出队或离队。其操作特性为先进后出（First In Last Out，FIFO），并且只允许在队尾进，队头出。   队头（Front）：允许删除的一端，又称队首   队尾（Rear）：允许插入的一端   空队列：不包含任何元素的空表   队列的基本操作   1）InitQueue（&Q）：初始化队
数据结构-队列实现银行排队
01-05
队列是一种先进先出（FIFO）的数据结构，它有两个主要操作：入队（enqueue）和出队（dequeue）。入队操作是在队列的尾部添加一个元素，而出队操作是从队列的头部移除一个元素。这种结构非常适合模拟现实世界中等待...
数据结构-队列的实现代码（C语言版）.rar
10-27
数据结构 -- C语言版 -- 队列的部分实现代码，详细介绍参考数据结构--队列的系列博文。链接为：https://blog.csdn.net/songshuai0223/category_9742561.html。
嵌入式常用数据结构------队列操作简介
08-21
队列是一种特殊的数据结构，它遵循“先进先出”（First In First Out，简称FIFO）的原则，类似于现实生活中的排队购票场景。在嵌入式软件开发中，队列被广泛应用于处理顺序执行的任务，例如任务调度、数据传输、消息...
基于C语言的数据结构-队列queue
06-25
在本主题“基于C语言的数据结构-队列queue”中，我们将深入探讨如何在C语言中实现队列的数据结构。 队列的基本操作包括： 1. **入队**（Enqueue）：将元素添加到队列的末尾。 2. **出队**（Dequeue）：移除并返回...
[Java · 铢积寸累] 数据结构 — 数组类型 - 增 & 删 & 改 & 查
Blue17 の 小窝
04-22 486
想系统化学习 Java 编程？在上一章中我们介绍了如何声明与创建数组，还介绍了数组的基本使用方式。本章我们将在上一章的基础上，拓展数组的使用方式（可能会涉及一些思维题）。
【数据结构】链表
2301_80802299的博客
04-23 674
思路三：创建小链表和大链表，遍历原链表，尾插到大小链表，将小链表的尾节点和大链表的第一个有效节点首尾相连。指向第一个节点的指针的地址 &plist<——>pphead。2. 遍历，count计节点数，返回(count / 2)的next节点。思路一：在原链表上修改，若pcur结点的值小于x,往后走；思路二：创建新链表，遍历原链表（若pcur结点的值小于x,带头：链表中有哨兵位节点，该哨兵位节点为头节点。1. 创建新链表，将原链表中的节点拿过来头插。链表由一个一个的节点组成，
数据结构——栈以及相应的操作
Peng_Kun的博客
04-19 479
入栈就像往弹夹中压子弹，出栈就像从弹夹中弹出子弹
【C语言-选择排序算法】实现对十个数进行排序
最新发布
m0_54032194的博客
04-23 627
在计算机科学领域，排序算法是基石般的存在，它们就像是整理杂乱数据的魔法，让无序的数据变得井井有条。而选择排序（Selection Sort），作为一种简单直观的排序算法，在学习排序的道路上是我们绕不开的经典算法之一。今天，我们一起探讨如何使用 C 语言实现选择排序算法，对十个数字进行排序，并详细剖析其中的原理与细节。通过以上详细的讲解和代码实现，我们深入了解了选择排序算法，并成功使用 C 语言对十个数字进行了排序。选择排序虽然在处理大规模数据时效率不高，但它简单易懂的特性使其成为学习排序算法的重要基础。
数据结构-队列的应用
07-28
回答: 队列是一种常见的数据结构，它遵循先进先出（FIFO）的原则。队列的应用非常广泛。其中一种应用是在操作系统中进行进程调度。操作系统使用队列来管理进程的执行顺序，确保每个进程按照一定的规则得到执行的机会。另一个应用是在计算机网络中进行数据传输。数据包在网络中按照队列的方式进行传输，以确保数据的有序性和可靠性。此外，队列还可以用于实现缓冲区，任务调度，消息传递等场景。总之，队列作为一种简单而有效的数据结构，在计算机科学和软件工程中有着广泛的应用。\[2\]\[3\] #### 引用[.reference_title] - *1* *2* *3* [算法与数据结构-队列的详解以及应用](https://blog.csdn.net/qq_53283658/article/details/122463796)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^koosearch_v1,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值