队列的实现（C语言）

最新推荐文章于 2025-03-12 20:25:46 发布
最新推荐文章于 2025-03-12 20:25:46 发布
阅读量1.8w 收藏 151
点赞数 35
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44695386/article/details/119494204
版权

循环队列 链式队列 数据结构 队列操作 存储优化
关键词由CSDN通过智能技术生成

队列的定义

队列（Queue） 是一种操作受限的线性表，只允许在表的一端进行插入，而在表的另一端进行删除。

队列操作的特性：先进先出（Frist In First Out）

在这里插入图片描述

队列的顺序存储–>循环队列

方案1：牺牲一个单元来区分队空和队满

在这里插入图片描述
实现：

// 顺序循环队列
// 方案1：牺牲一个单元来区分队空和队满
// 队尾指针指向 队尾元素的后一个位置（下一个应该插入的位置）

#define MaxSize 50	//定义队列中元素的最大个数
typedef int ElemType;
typedef struct{
	ElemType data[MaxSize];		//存放队列元素
	int front;		//队头指针
	int rear;		//队尾指针
}SeqQueue;

// 初始化队列
void InitQueue(SeqQueue& q)
{
	q.front = q.rear = 0;
}

// 判断队列是否为空
bool QueueEmpty(SeqQueue& q)
{
	if (q.rear == q.front)	//队空条件
		return true;
	else
		return false;
}

// 入队
bool EnQueue(SeqQueue& q, ElemType x)
{
	if ((q.rear+1) % MaxSize == q.front)
		return false;		//队列满则报错

	q.data[q.rear] = x;		//将x插入队尾
	q.rear = (q.rear + 1) % MaxSize;    //队尾指针后移
	return true;
}

// 出队
bool DeQueue(SeqQueue& q, ElemType& x)
{
	if (q.rear == q.front)
		return false;	//队空则报错

	x = q.data[q.front];
	q.front = (q.front + 1) % MaxSize; //队头指针后移
	return true;
}

// 获取队头元素
bool GetHead(SeqQueue& q, ElemType& x)
{
	if (q.rear == q.front)
		return false;	//队空则报错
	
	x = q.data[q.front];
	return true;
}

// 队列中元素的个数
int QueueNum(SeqQueue& q)
{
	return (q.rear - q.front + MaxSize) % MaxSize;
}

方案2：增设表示元素个数的变量（不牺牲存储单元）

在这里插入图片描述
实现：

// 方案2：不浪费存储空间
// 设置一个变量size，记录队列当中存储元素的个数
// 队尾指针指向 队尾元素的后一个位置（下一个应该插入的位置）

#define MaxSize 50
typedef int ElemType;
typedef struct{
	ElemType data[MaxSize];
	int front;
	int rear;
	int size;	//队列当前长度 
}SeqQueue;

// 初始化队列
void InitQueue(SeqQueue& q)
{
	q.front = q.rear = 0;
	q.size = 0;		//队列当前长度为0
}

// 判断队列是否为空
bool QueueEmpty(SeqQueue& q)
{
	if (q.size==0)	//队空条件
		return true;
	else
		return false;
}

// 入队
bool EnQueue(SeqQueue& q, ElemType x)
{
	if (q.size==MaxSize)
		return false;		//队列满则报错

	q.data[q.rear] = x;		//将x插入队尾
	q.rear = (q.rear + 1) % MaxSize;    //队尾指针后移
	q.size++;
	return true;
}

// 出队
bool DeQueue(SeqQueue& q, ElemType& x)
{
	if (q.size==0)
		return false;	//队空则报错

	x = q.data[q.front];
	q.front = (q.front + 1) % MaxSize; //队头指针后移
	q.size--;
	return true;
}

// 获取队头元素
bool GetHead(SeqQueue& q, ElemType& x)
{
	if (q.size==0)
		return false;	//队空则报错

	x = q.data[q.front];
	return true;
}

// 队列中元素的个数
int QueueNum(SeqQueue& q)
{
	return q.size;
}

方案3：增设tag数据成员区分队空队满（不牺牲存储单元）

在这里插入图片描述
实现：

// 方案3：设置tag数据成员，以区分队满还是队空
// 不浪费存储空间

#define MaxSize 50
typedef int ElemType;
typedef struct{
	ElemType data[MaxSize];
	int front;
	int rear;
	int tag; //最近进行的是删除/插入操作

}SeqQueue;

// 初始化队列
void InitQueue(SeqQueue& q)
{
	q.front = q.rear = 0;
	q.tag = 0;
}

// 判断队列是否为空
bool IsEmpty(SeqQueue& q)
{
	if (q.front == q.rear && q.tag == 0) //队空条件
		return true;
	else
		return false;
}

// 入队
// 只有插入操作，才可能导致队满
bool EnQueue(SeqQueue& q, ElemType x)
{
	if (q.front == q.rear && q.tag == 1)
		return false;	//队满则报错

	q.data[q.rear] = x;
	q.rear = (q.rear + 1) % MaxSize;	//队尾指针加1取模
	q.tag = 1;	//每次插入操作成功时，都令tag=1;

	return true;
}

// 出队
// 只有删除操作，才可能导致队空
bool EnQueue(SeqQueue& q, ElemType& x)
{
	if (q.front == q.rear && q.tag == 0)
		return false;	//队空则报错

	x = q.data[q.front];
	q.front = (q.front + 1) % MaxSize;	//队头指针加1取模
	q.tag = 0;	//每次出队成功时，都令tag=0;

	return true;
}

// 获取队头元素
bool GetHead(SeqQueue& q, ElemType& x)
{
	if (q.front==q.rear && q.tag==0)
		return false;	//队空则报错

	x = q.data[q.front];
	return true;
}

链式队列的实现

带头结点的链式队列

在这里插入图片描述

// 队列的链式存储实现(带头节点)

typedef int ElemType;
typedef struct LinkNode{
	ElemType data;
	struct LinkNode* next;
}LinkNode;

typedef struct{
	LinkNode* front;	//头指针指向头结点
	LinkNode* rear;		//尾指针指向尾节点
	int length;			//队列长度
}LinkQueue;

// 初始化队列
void InitQueue(LinkQueue& q)
{
	//初始时front，rear都指向头结点
	q.front = q.rear = (LinkNode*)malloc(sizeof(LinkNode));	//建立头结点
	q.front->next = NULL;
	q.length = 0;
}

// 判断队列是否为空
bool IsEmpty(LinkQueue& q)
{
	if (q.front == q.rear)
		return true;
	else
		return false;
}

// 入队
bool EnQueue(LinkQueue& q, ElemType x)
{
	LinkNode* s = (LinkNode*)malloc(sizeof(LinkNode));
	s->data = x;
	s->next = NULL;

	q.rear->next = s;	//新节点插入到rear之后
	q.rear = s;			//修改表尾指针

	q.length++;
	return true;
}

// 出队
bool DeQueue(LinkQueue& q, ElemType& x)
{
	if (q.front == q.rear)
		return false;	//空队

	LinkNode* p = q.front->next;
	x = p->data;	//用变量x返回队头元素

	q.front->next = p->next;	//修改头结点的next指针
	if (q.rear = p) //若是最后一个结点出队
		q.rear = q.front;
	free(p);		//释放节点空间

	q.length--;
	return true;
}

// 求队列长度
int LengthQueue(LinkQueue& q)
{
	return q.length;
}

不带头结点的链式队列

在这里插入图片描述

// 链式队列的实现(不带头结点)

typedef int ElemType;
typedef struct LinkNode{
	ElemType data;
	struct LinkNode* next;
}LinkNode;

typedef struct{
	LinkNode* front;
	LinkNode* rear;
	int length;
}LinkQueue;

// 初始化队列
void InitQueue(LinkQueue& q)
{
	//初始时 front，rear都指向NULL
	q.front = NULL;
	q.rear = NULL;
}

// 判断队列是否为空
bool IsEmpty(LinkQueue& q)
{
	if (q.front == NULL)
		return true;
	else
		return false;
}

// 入队
void EnQueue(LinkQueue& q, ElemType x)
{
	LinkNode* s = (LinkNode*)malloc(sizeof(LinkNode));
	s->data = x;
	s->next = NULL;

	if (q.front == NULL)	//在空队列中插入第一个元素
	{
		q.front = s;
		q.rear = s;
	}
	else
	{ 
		q.rear->next = s;	//	新节点插入到rear节点之后
		q.rear = s;		    // 修改rear指针
	}
	q.length++;
}

// 出队
bool DeQueue(LinkQueue& q, ElemType& x)
{
	if (q.front == NULL)
		return false;	//队空则报错

	LinkNode* p = q.front;    //p指向此次出队的节点
	x = p->data;			  //用变量x返回队头指针

	q.front = p->next;		  //修改front指针
	if (q.rear == p)		  //此次是最后一个节点出队	
	{
		q.front = NULL;		  //front指向NULL
		q.rear = NULL;		  //rear指向NULL
	}
	free(p);

	q.length--;
	return true;
}

// 求队列长度
int LengthQueue(LinkQueue& q)
{
	int count = 0;
	LinkNode* p = q.front;
	while (p != NULL)
	{
		++count;
		p = p->next;
	}
	return count;
}
【数据结构】链队列的C语言实现
Sherry的博客
03-22 1668
今天我们认识并学习了队列的相关概念、结构与接口实现，并且针对每个常用的功能接口进行了实现。总体来说，链队列的结构相比于之前的数据结构是比较简单的，之后将介绍和讲解栈与队列的相关OJ题。希望我的文章和讲解能对大家的学习提供一些帮助。
队列的实现（c语言实现）
2301_80224556的博客
04-25 1419
队列（Queue）是一种特殊的线性数据结构，它遵循先进先出（FIFO，First In First Out）的原则。这意味着最早被添加到队列中的元素将是最先被移除的元素。队列的主要操作包括入队（enqueue，在队列的尾部添加元素）和出队（dequeue，从队列的头部移除元素）。队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊。：队列的插入操作叫做入队列，：队列的删除操作叫做出队列，
C语言实现队列
2401_86557724的博客
09-29 1310
本章使用C语言实现了数据结构中的队列，队列的结构也不是很难，实现难度也不是很大，但是队列的作用却很大，值得我们去亲自实现它。
C语言实现队列数据结构：思路与代码详解
最新发布
nplplus的博客
03-12 1450
c_CRT_SECURE_NO_WARNINGS 宏定义用于关闭Visual Studio中一些函数的安全警告。后面依次包含了标准输入输出库、标准库、布尔类型库和断言库，为后续代码提供必要的功能支持。c}QNode;int size;}Queue;- QDatatype 定义为 int 类型，表示队列中存储的数据类型，这里是整型，也可以根据实际需求改为其他类型。
队列的实现程序（c语言）
06-03
队列的实现程序（c语言），数据结构学习必备
队列——（c语言实现）
2302_77041624的博客
05-12 3264
队列，是一种先进先出（first in first out 简称FIFO）的数据结构，是只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，在队列中，进行插入的一端称为队尾，进行删除的一端称为队头。
队列实现
weixin_34077371的博客
09-17 93
队列是一个先进先出的算法，正好和之前的堆栈相对应，堆栈是先进后出，他们两个在不同的问题上都有自己各自的用处，在这里就是用C++实现自己的队列，并扩展了一些函数来供我们使用。好了，话不多了，直接上代码的实现部分： //============================================================================ // Na...
队列的实现(C语言版)
学代码的咸鱼的博客
04-27 1923
文章目录队列的概念及结构队列的实现 队列的概念及结构 队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出的原则。 入队列：进行插入操作的一端称为队尾。 出队列：进行删除操作的一端称为队头。 队列的实现 ...
【C语言】队列的实现
m0_62537611的博客
06-28 2801
队列的概念和结构 队列的模拟实现：用代码定义队列的结构队列基本功能的实现 初始化队列队尾入数据对头出数据获取对列对头元素获取队列对尾元素判空获取队列中有效元素的个数销毁队列完整代码头文件源文件队列的概念：队列只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列中的数据结构遵循先进先出FIFO(First In First Out)或后进后出的原则。入队列：进行插入操作的一端称为队尾出队列：进行删除操作的一端称为队头队列的结构：要实现队列无非也是现在我们学的两种结构：数组和链式结构。但是用
51单片机串口接收使用队列C语言实现
02-24
下面是一个简单的队列实现示例： 1. 定义队列结构： ```c typedef struct { uint8_t data[QUEUE_SIZE]; // 队列容量，可根据实际需求调整 int front; // 队头指针 int rear; // 队尾指针 } Queue; ``` 2. 初始...
优先队列——C语言实现
likunkun__的博客
08-25 4665
队列的特点是，先进先出。 优先队列的特点是，进来的，根据优先次序，一个个出来。我们可以使用堆的思想来解决这个问题。 代码： 堆的实现参照：堆——用C语言实现，里面会用到 头文件（包含堆）： #define _CRT_SECURE_NO_WARNINGS 1 #include <stdio.h> #include <assert.h> #include <...
c语言实现队列功能
11-04
c语言实现队列功能，push、pop多字节与单字节，方便调用。
顺序存储和链式存储的泛型队列_C语言项目
04-12
本项目专注于实现顺序存储和链式存储的泛型队列，使用C语言作为编程工具，旨在提供灵活且高效的操作接口。下面我们将深入探讨相关知识点。 首先，队列是一种先进先出（First In First Out, FIFO）的数据结构，它的...
队列_队列、C语言_
10-02
C语言虽然没有内置的队列类型，但我们可以使用结构体和指针来实现自己的队列数据结构。 在提供的文件中，我们有三个关键的文件：`queue.c`、`use_q.c`和`queue.h`。`queue.c`通常包含了队列数据结构的定义和相关...
队列及其基本概念
serase的博客
10-26 786
1 队列的基本概念 队列(Queue)：也是运算受限的线性表。是一种先进先出(First In First Out ，简称FIFO)的线性表。只允许在表的一端进行插入，而在另一端进行 删除。 队首(front) ：允许进行删除的一端称为队首。 队尾(rear) ：允许进 行插入的一端称为队尾。 2 队列的抽象数据类型定义 ADT Queue{ 数据对象：D ={ ai|ai∈ElemSet, i=1, 2, …, n, n >= 0 数据关系：R = { | ai-1, ai∈D, i=2,3,…,
队列（c语言实现）
不负韶话
01-07 7446
目录 前言 一、队列是什么？ 二、队列的属性与操作以及种类 1.队列属性 2.队列操作 3.队列种类 三、队列的实现（C语言） 总结 前言 本文旨在帮助刚接触队列的人更快的掌握，语言不够严谨，望海涵。 栗子 一对情侣准备在情人节去电影院看电影，男的是个身穿格子衫的程序员，我们就称之为小木，由于排队买票的人特别多，所以排了很长的队，小木遵守道德，在队伍最后面排队。排了很久，发现前面队伍一直不动，自己一直排在最后，小木就有点奇怪，往前一瞧，原来是排他后面的人都直接插到最前...
队列的基本概念及实现
weixin_43755584的博客
04-11 329
队列的基本概念 队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出的特性。 队列的实现：队列可以数组和链表的结构实现，使用链表的结构实现更优一些，因为如果使用数组的结构，出队列在数组头上出数据，效率比较低。 以下是实现队列的基本操作 #pragma once typedef struct Node { int value; struct Node *next...
队列（C语言实现）
m0_59311392的博客
09-18 4047
1.1 定义：队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出 FIFO(First In First Out)入队列：进行插入操作的一端称为队尾出队列：进行删除操作的一端称为队头int front;int rear;}QueNode;int size;}Queue双端队列是指允许两端都可以进行入队和出队操作的队列。其元素的逻辑结构仍是线性结构。将队列的两端称为前端和后端，两端都可以入队和出队。
评论 13
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值