c语言实现动态增容循环队列

最新推荐文章于 2024-05-12 19:01:24 发布
最新推荐文章于 2024-05-12 19:01:24 发布
阅读量610 收藏 1
点赞数 1
分类专栏： c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013113678/article/details/120634140
版权

c语言 数据结构 队列

队列在日常开发中有时还是会用到的，比如实现一个消息队列时底层就需要一个队列、又或者实现图的广度遍历也需要用到队列。c语言标准库是没有队列这种结构提供的，这里提供一个种队列的实现方法，在c语言的环境下能够方便的使用。
一、接口设计
1、数据结构
这里直接把结构体定义在头文件，以方便使用者自由选择堆栈内存实例化。一个循环队列通常需要，一个头下标、一个尾下标、一个数组即可。这里为了实现动态增容添加数组容量字段，用以记录当前数组的长度。还添加了元素大小字段，用以适应不同的数据类型。最后增加了一个元素个数，这个字段不是必须的,循环队列的长度和队列空都可以通过头尾下标以及数组长度来计算，这里添加元素个数是为了减少计算量以空间换时间，以及节省一个头下标指向的元素空间。具体代码如下：

#include<stdint.h>
#include<stddef.h>
/// <summary>
/// 队列
/// </summary>
typedef struct {
	/// <summary>
    /// 头下标
    /// </summary>
	size_t _front;
	/// <summary>
	/// 尾下标
	/// </summary>
	size_t _rear;
	/// <summary>
    /// 数据数组
    /// </summary>
	uint8_t* _data;
	/// <summary>
	/// 数组容量
	/// </summary>
	size_t _capacity;
	/// <summary>
    /// 元素大小
    /// </summary>
	size_t _elementSize;
	/// <summary>
	/// 元素个数
	/// </summary>
	size_t _count;
}acf_queue;

2、方法
（1）初始化
队列使用前需要初始化，传入队列对象的指针，以及队列元素的大小即可初始化队列。

/// <summary>
/// 初始化队列
/// </summary>
/// <param name="queue">队列对象的指针</param>
/// <param name="_elementSize">元素大小</param>
void acf_queue_init(acf_queue* queue, size_t elementSize);

（2）反初始化
使用完成后，需要反初始化队列以释放资源。

/// <summary>
/// 反初始化队列
/// </summary>
/// <param name="queue">队列对象的指针</param>
void acf_queue_deinit(acf_queue* queue);

（3）入队
将元素压入对尾，传入的是元素的指针，当元素个数大于队列数组时，会自动增容。

/// <summary>
/// 入队
/// </summary>
/// <param name="queue">队列对象的指针</param>
/// <param name="pElement">元素的指针</param>
void acf_queue_enqueue(acf_queue* queue, void* pElement);

（4）出队
队头元素出队，如果队列不为空出队且返回成功，否则返回失败。

/// <summary>
/// 出队
/// </summary>
/// <param name="queue">队列对象的指针</param>
/// <returns>1出队成功，0失败</returns>
int acf_queue_dequeue(acf_queue* queue);

（5）获取队头元素
只获取队头元素而不出队。返回队头元素的指针。

/// <summary>
/// 获取队头元素
/// </summary>
/// <param name="queue">队列对象的指针</param>
/// <returns>队头元素的指针</returns>
void* acf_queue_peek(acf_queue* queue);

（6）获取元素
根据下标获取元素。返回队头元素的指针。

/// <summary>
/// 获取元素
/// </summary>
/// <param name="queue">队列对象的指针</param>
/// <param name="index">元素的下标</param>
/// <returns>队头元素的指针</returns>
void* acf_queue_get_element(acf_queue* queue, size_t index);

（7）获取队列长度
获取队列中元素的个数。

/// <summary>
/// 获取队列长度
/// </summary>
/// <param name="queue">队列对象的指针</param>
/// <returns>队列长度</returns>
size_t acf_queue_get_count(acf_queue* queue);

（8）获取队列容量
获取当前队列数组长度。

/// <summary>
/// 获取队列容量
/// </summary>
/// <param name="queue"></param>
/// <returns>队列容量</returns>
size_t acf_queue_get_capacity(acf_queue* queue);

（9）清空队列
清除队列中的所有元素。

/// <summary>
/// 清空队列
/// </summary>
/// <param name="queue">队列对象的指针</param>
void acf_queue_clear(acf_queue* queue);

（10）容量收缩
将队列数组长度，收缩至元素个数大小。

/// <summary>
/// 容量收缩
///队列只会根据元素增加增容，不会根据元素减少减容，需要减容则调用此方法。
/// </summary>
/// <param name="queue">队列对象的指针</param>
void acf_queue_trim_excess(acf_queue* queue);

二、关键实现
1、动态增容

（1）malloc版本
malloc版本主要用于减容，即收缩数组的时候需要用到。

static int acf_queue_set_capacity_malloc(acf_queue* _this, size_t newCapacity) {
	if (newCapacity < _this->_count)
		return 0;
	if (newCapacity == _this->_capacity)
		return 1;
	uint8_t* newData = NULL;
	if (newCapacity)
	{
		newData = malloc(newCapacity * _this->_elementSize);
		if (_this->_count > 0)
		{
			if (_this->_front < _this->_rear)
			{
				memcpy(newData, _this->_data + (_this->_front) * _this->_elementSize, _this->_count * _this->_elementSize);
			}
			else
			{
				memcpy(newData, _this->_data + (_this->_front) * _this->_elementSize, (_this->_capacity - _this->_front) * _this->_elementSize);
				memcpy(newData + (_this->_capacity - _this->_front) * _this->_elementSize, _this->_data, (_this->_rear) * _this->_elementSize);
			}
		}
	}
	_this->_front = 0;
	_this->_rear = _this->_count;
	_this->_capacity = newCapacity;
	_this->_data = newData;
	return 1;
}

（2）realloc版本
realloc版本在倍速增容中比malloc版本效率高。具体实现如下。

static int acf_queue_set_capacity_realloc(acf_queue* _this, size_t newCapacity) {
	if (newCapacity < _this->_count)
		return 0;
	if (newCapacity == _this->_capacity)
		return 1;
	if (newCapacity <_this->_capacity)
		return 0;
	 uint8_t* newData = realloc(_this->_data, newCapacity * _this->_elementSize);
	if (!newData)
		return 0;
	_this->_data = newData;
	if (_this->_front >= _this->_rear)
	{
		if (newCapacity - _this->_capacity < _this->_rear)
		{
			memcpy(_this->_data + _this->_capacity * _this->_elementSize, _this->_data, (newCapacity - _this->_capacity) * _this->_elementSize);
			memmove(_this->_data, _this->_data + ((newCapacity - _this->_capacity) * _this->_elementSize), (_this->_rear - (newCapacity - _this->_capacity)) * _this->_elementSize);
			_this->_rear -= (newCapacity - _this->_capacity);
		}
		else
		{
			memcpy(_this->_data + (_this->_capacity) * _this->_elementSize, _this->_data, _this->_rear * _this->_elementSize);
			_this->_rear = _this->_capacity + _this->_rear ;
		}
	}
	_this->_capacity = newCapacity;
	return 1;
}

（3）组合
根据不同的情况使用不同的策略。这里只是简单的进行了数组容量判断，如果细化还可以根据元素个数在数组中的占比做出不同的选择策略。

static int acf_queue_set_capacity(acf_queue* _this, size_t newCapacity) {
	if (newCapacity < _this->_capacity)
	{
		acf_queue_set_capacity_malloc(_this, newCapacity);
	}
	else
	{
		acf_queue_set_capacity_realloc(_this, newCapacity);
	}
}

2、入队
入队前需要判断元素是否已满，已满则需要增容，增容方式是2倍增容。具体实现如下：

void acf_queue_enqueue(acf_queue* _this, void* pData)
{
	if (_this->_count == _this->_capacity)
	//队满
	{
		if (_this->_capacity < 4)
			acf_queue_set_capacity(_this, 4);
		else
			acf_queue_set_capacity(_this, _this->_capacity *2);
	}
	memcpy(_this->_data + _this->_rear * _this->_elementSize, pData, _this->_elementSize);
	_this->_rear = (_this->_rear + 1) % _this->_capacity;
	_this->_count++;
}

3、容量收缩
当队列数组容量过大时，可以手动调用容量收缩方法以减少不必要的空间浪费。参照了c#的queue具体实现如下：

void acf_queue_trim_excess(acf_queue* _this) {
	size_t threshold = (size_t)(((double)_this->_capacity) * 0.9);
	if (_this->_count < threshold) {
		acf_queue_set_capacity(_this, _this->_count);
	}
}

三、使用例子
1、整型元素
main.c

#include "Collection/acf_queue.h"
#include<stdio.h>
int main()
{
	acf_queue queue1;
	//初始化
	acf_queue_init(&queue1, sizeof(int));
	//入队
	for (int i = 0; i < 50; i++)
	{
		acf_queue_enqueue(&queue1, &i);
	}
	//获取元素个数
	printf("count:%d\n", acf_queue_get_count(&queue1));
	//获取数组容量
	printf("capacity:%d\n", acf_queue_get_capacity(&queue1));
	//容量收缩
	acf_queue_trim_excess(&queue1);
	//获取数组容量
	printf("trim capacity:%d\n", acf_queue_get_capacity(&queue1));
	printf("dequeue:");
	//出队
	do {
		int* pI = acf_queue_peek(&queue1);
		if (pI)
			printf("%d ", *pI);
	} while (acf_queue_dequeue(&queue1));
	printf("\n");
	//入队
	for (int i = 0; i < 50; i++)
	{
		acf_queue_enqueue(&queue1, &i);
	}
	//遍历队列
	printf("traverse:");
	for (int i = 0; i < 50; i++)
	{
		int* pI = acf_queue_get_element(&queue1, i);
		if (pI)
			printf("%d ", *pI);
	}
	printf("\n");
	//清除元素
	acf_queue_clear(&queue1);
	printf("clear count:%d\n", acf_queue_get_count(&queue1));
	//反初始化
	acf_queue_deinit(&queue1);
	return 0;
}

2、结构体元素

#include "Collection/acf_queue.h"
#include<stdio.h>
typedef struct  
{
	int i;
	int j;
}A;

int main()
{
	acf_queue queue2;
	//初始化
	acf_queue_init(&queue2, sizeof(A));
	//入队
	for (int i = 0; i < 50; i++)
	{
		A a;
		a.i = i;
		a.j = i;
		acf_queue_enqueue(&queue2, &a);
	}
	//获取元素个数
	printf("count:%d\n", acf_queue_get_count(&queue2));
	//获取数组容量
	printf("capacity:%d\n", acf_queue_get_capacity(&queue2));
	//容量收缩
	acf_queue_trim_excess(&queue2);
	//获取数组容量
	printf("trim capacity:%d\n", acf_queue_get_capacity(&queue2));
	printf("dequeue:");
	//出队
	do {
		A* pA = acf_queue_peek(&queue2);
		if (pA)
			printf("%d ", pA->i);
	} while (acf_queue_dequeue(&queue2));
	printf("\n");
	//入队
	for (int i = 0; i < 50; i++)
	{
		A a;
		a.i = i;
		a.j = i;
		acf_queue_enqueue(&queue2, &a);
	}
	//遍历队列
	printf("traverse:");
	for (int i = 0; i < 50; i++)
	{
		A* pA = acf_queue_get_element(&queue2, i);
		if (pA)
			printf("%d ", pA->j);
	}
	printf("\n");
	//清除元素
	acf_queue_clear(&queue2);
	printf("clear count:%d\n", acf_queue_get_count(&queue2));
	//反初始化
	acf_queue_deinit(&queue2);
	return 0;
}

3、指针元素

#include "Collection/acf_queue.h"
#include<stdio.h>
#include<stdlib.h>
typedef struct  
{
	int i;
	int j;
}A;
int main()
{

		acf_queue queue3;
		//初始化
		acf_queue_init(&queue3, sizeof(A*));
		//入队
		for (int i = 0; i < 50; i++)
		{
			A* a = malloc(sizeof(A));
			a->i = i;
			a->j = i;
			acf_queue_enqueue(&queue3, &a);
		}
		//获取元素个数
		printf("count:%d\n", acf_queue_get_count(&queue3));
		//获取数组容量
		printf("capacity:%d\n", acf_queue_get_capacity(&queue3));
		//容量收缩
		acf_queue_trim_excess(&queue3);
		//获取数组容量
		printf("trim capacity:%d\n", acf_queue_get_capacity(&queue3));
		printf("dequeue:");
		//出队
		do {
			A** pA = acf_queue_peek(&queue3);
			if (pA)
			{
				printf("%d ", (*pA)->i);
				//释放资源防止内存泄漏
				free(*pA);
			}
		} while (acf_queue_dequeue(&queue3));
		printf("\n");
		//入队
		for (int i = 0; i < 50; i++)
		{
			A* a = malloc(sizeof(A));
			a->i = i;
			a->j = i;
			acf_queue_enqueue(&queue3, &a);
		}
		//遍历队列
		printf("traverse:");
		for (int i = 0; i < 50; i++)
		{
			A** pA = acf_queue_get_element(&queue3, i);
			if (pA)
			{
				printf("%d ", (*pA)->j);
				//释放资源防止内存泄漏
				free(*pA);
			}
		}
		printf("\n");
		//清除元素
		acf_queue_clear(&queue3);
		printf("clear count:%d\n", acf_queue_get_count(&queue3));
		//反初始化
		acf_queue_deinit(&queue3);
	return 0;
}

四、完整代码
https://download.csdn.net/download/u013113678/29027672

CodeOfCC
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C语言动态创建队列
12-26
这是一个动态创建数据结构队列的例子，工作中可以参考甚至使用，不过还是侧重学习比较好，欢迎下载。
可扩充循环队列
09-26
可扩充循环队列可扩充循环队列可扩充循环队列可扩充循环队列可扩充循环队列
动态队列——基于C语言
qq_38705421的博客
08-13 465
使用之前实现了的链表实现了数据结构中的动态队列 下面是Main.c文件： #include "DynamicQueue.h" #include <stdio.h> int main() { DynamicQueue* queue = DynamicQueueCreate(); if(queue != NULL) { int i, len = -1, data = -1; for(i = 0; i < 100; i++) { DynamicQueueEnq
动态顺序队列 C语言
qq_43402544的博客
10-10 437
数据结构c语言动态顺序队列的实现和表示 代码如下： #include <stdio.h> #include <stdlib.h> #define InitSize 6 typedef struct { int *base;//存储空间的基地址 int front;//头指针 int rear;//尾指针 int MAXSIZE;//队列存储最大值 }SqQueue; void InitQueue(SqQueue &Q)//初始化队列 { Q.base
【C】自定义实现循环队列 queue 入队、出队和扩容（非链队列）（code c）
idiot5lie的博客
03-11 288
目录&索引程序代码实现队列queue循环插入和删除 code c运行结果结论 程序代码 实现队列queue循环插入和删除 code c #include <stdio.h> #include <stdlib.h> #include <time.h> typedef struct Queue { int *data; int head, tail, size; // tail指向末尾元素的下一个位置 int count; } Queue;
用循环队列实现斐波那契数列的输出
03-27
在C语言中，我们可以使用结构体来表示循环队列，包含数据元素、队头和队尾的指针。为了实现斐波那契数列，我们可以利用循环队列的特性，将最近的两个斐波那契数作为队列中的元素，并通过出队和入队操作计算新的...
C语言实现数据结构：单链表，循环链表，双向链表；静态顺序队列
10-19
这种结构允许在链表的末尾执行更快的操作，例如在循环队列中。 3. **双向链表**： 双向链表的每个节点包含三个部分：数据域和两个指针域，分别指向前后两个节点。双向链表提供了更灵活的访问，可以从任一方向遍历...
数据结构算法C语言代码实现集合
03-31
这里可能包括了普通队列和循环队列的实现。 6. **栈**：栈是后进先出（LIFO）的数据结构，常用于表达式求值、递归、函数调用等场景。栈的操作主要有push（入栈）和pop（出栈）。 7. **图**：图由顶点和边组成，...
数据结构及算法C语言实现代码集
05-15
当队列满或空时，需要考虑扩容或缩容操作。 10. **链栈.c**：栈是一种后进先出（LIFO）的数据结构，链栈用链表实现，提供压栈（入栈）、弹栈（出栈）和查看栈顶元素等操作。栈在递归、表达式求解和函数调用等方面有...
C语言实现队列，可做基础库
08-17
C语言实现队列，测试功能完整，可以在作为基础库开发。 包含接口：Queue_Init、Queue_Free、Queue_AddToHead、Queue_AddToTail、Queue_GetFromHead、Queue_GetFromTail、OnQueueIncreasedEvent
循环队列如何根据实际需要动态地扩展空间？
weixin_42575505的博客
01-07 225
循环队列可以使用动态数组的实现方式来动态地扩展空间。 当队列满时，我们可以创建一个新的更大的数组，然后把旧数组中的数据拷贝到新数组中，再将旧数组指针指向新数组，这样就可以继续向队列中添加元素了。 但是，当我们扩展数组的大小时，需要注意保证队列的循环性，也就是说，需要把队列的队尾元素正确地放在新数组的最后一个位置。 例如，假设当前队列的容量为 4，已有元素 A, B, C, D，其中队尾元素为 D，...
队列——（c语言实现）
最新发布
2302_77041624的博客
05-12 1510
队列，是一种先进先出（first in first out 简称FIFO）的数据结构，是只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，在队列中，进行插入的一端称为队尾，进行删除的一端称为队头。
队列 C语言实现
fulangsuowa的博客
10-30 744
嵌入式软件中，受硬件内存所限，最好别采用动态分配和回收，对于某些数据结构，最好提前分配好内存，便于管理。 自己实现一个队列的数据结构，用作备份。   /* 队列结构，队列大小XXX_QUEUE_SIZE和事件结构XXX_T根据需要自己定义 */ typedef struct {     u16     usFront;    /* 队首 */     u16     usRe
C语言 实现循环队列
z745517892的博客
09-25 933
文章目录C语言 实现循环队列一、基本概念及注意事项1.基本概念2.注意事项二、C语言实现一个简单的循环队列 C语言 实现循环队列 一、基本概念及注意事项 1.基本概念 队列是一种特殊的线性表结构，特殊之处在于它只允许在表的前端(front)删除元素，在表的尾端(rear)插入元素。因此队列是一种先入先出(FIFO)的数据结构。进行插入操作的端称为队尾，进行删除操作的端称为队头。 循环队列就是将队列存储空间的最后一个位置绕到第一个位置，形成逻辑上的环状空间，供队列循环使用。 2.注意事项 1.在循环队列中，当
c语言链式存储队列,队列的动态链式存储实现—C语言
weixin_42410443的博客
05-17 130
头文件ElemType.h/****ElemType.h - ElemType的定义*****/#ifndef ELEMTYPE_H#define ELEMTYPE_Htypedef int ElemType;int compare(ElemType x, ElemType y);void visit(ElemType e);#endif /* ELEMTYPE_H */DynaLnkQueue...
队列扩容
weixin_30299539的博客
06-07 451
template<class T> void Queue<T>::Push(const T& item){　　/*if (rear == capacity-1)　　{　　　　rear = 0;　　}　　else 　　{　　　　rear++;　　}*/ 　　//判断队列是否存满　　if ((rear+1)%capacity == front)　　{　　　　//加倍　...
可自动增长队列长度的泛型循环队列
03-01 151
最近不忙，随便写写！队列代码：///<summary>///一个可以自动增长长度的队列，并且可以重复循环队列///</summary>///<typeparamname="T">自定义的泛型</typeparam>classQueue<T>{//队列出队index...
c语言下循环队列的使用,C语言实现循环队列
weixin_35144564的博客
05-22 381
本文实例为大家分享了C语言实现循环队列的具体代码，供大家参考，具体内容如下注意事项：1、循环队列，是队列的顺序表示和实现。因为是尾进头出，所以和顺序栈不同的是需要将顺序队列臆造成一个环状的空间，以便在尾部添加满之后从头部空位开始插入。2、也可以使用数组队列，也就是不能动态增长的顺序队列，这样不需要每次取模最大值来构成环形空间。每次插入新的队列尾元素时，尾指针增1，每当删除队列头元素时，头指针增1。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

CodeOfCC

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

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

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

打赏作者

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

抵扣说明：

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

余额充值