数据结构----队列

最新推荐文章于 2024-09-06 21:08:02 发布
最新推荐文章于 2024-09-06 21:08:02 发布
阅读量60 收藏
点赞数
分类专栏： # 数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/SDTyuan/article/details/132312120
版权

>>> 队列的顺序存储

前提：利用之前已经写好的动态数组实现队列的顺序存储，数组首地址做对头。

两个头文件：动态数组头文件和队列的头文件

//dynamic_array.h

#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

//动态数组结构体
struct dynamicArray
{
	void** pAddr;
	int m_capacity;
	int m_size;
};

//初始化数组
struct dynamicArray* initDynamicArray(int capacity);
//插入
void insertDynamicArray(struct dynamicArray* arry, int pos, void* data);
//遍历数组
void foreachDynamicArray(struct dynamicArray* arry, void(*myPrint)(void*));
//按位置删除数组元素
void removeByPosDynamicArray(struct dynamicArray* arry, int pos);
//按值删除
void removeByValueDynamicArray(struct dynamicArray* arry, void* data, int(*myCompare)(void*, void*));
//销毁数组
void destroyDynamicArray(struct dynamicArray* arry);
//seq_queue.h

#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "dynamic_array.h"

#define MAX 1024  //队列容量
typedef void* SeqQueue;

//初始化队列
SeqQueue initSeqQueue();
//出队
void popSeqQueue(SeqQueue queue);
//入队
void pushSeqQueue(SeqQueue queue, void* data);
//返回队列大小
int sizeSeqQueue(SeqQueue queue);
//判断队列是否为空
int isEmptySeqQueue(SeqQueue queue);
//返回队头元素
void* frontSeqQueue(SeqQueue queue);
//返回队尾元素
void* backSeqQueue(SeqQueue queue);
//销毁队列
void destroySeqQueue(SeqQueue queue);

三个源文件：动态数组的具体实现文件、队列的具体实现文件和测试文件

//dynamic_array.c

#include "dynamic_array.h"

//初始化数组
struct dynamicArray* initDynamicArray(int capacity)
{
	//1.判断输入容量
	if (capacity <= 0)
	{
		return NULL;
	}

	//2.给数组结构体分配空间
	struct dynamicArray* arry = (struct dynamicArray*) malloc(sizeof(struct dynamicArray));
	if (arry == NULL)
	{
		return NULL;
	}

	//3.数组结构体属性初始化
	arry->pAddr = (void**)malloc(sizeof(void*) * capacity);
	arry->m_capacity = capacity;
	arry->m_size = 0;

	return arry;
}

//插入
void insertDynamicArray(struct dynamicArray* arry, int pos, void* data)
{
	//1.判断输入参数的有效性
	if (arry == NULL || data == NULL)
	{
		return;
	}
	if (pos < 0 || pos > arry->m_size)  //pos越界，默认尾插
	{
		pos = arry->m_size;
	}

	//2.判断数组是否已满，满了动态扩展
	if (arry->m_size == arry->m_capacity)
	{
		int new_capacity = arry->m_capacity * 2;  //新空间大小

		void** new_space = (void**)malloc(sizeof(void*) * new_capacity);   //开辟新空间

		memcpy(new_space, arry->pAddr, sizeof(void*) * arry->m_capacity);  //将原有数据拷贝到新空间

		free(arry->pAddr);  //释放原来空间
		arry->pAddr = new_space;  //指向新空间
		arry->m_capacity = new_capacity;  //更新容量
	}

	//3.pos位置后的元素向后移动一位，注意：从右向左移动方便
	for (int i = arry->m_size - 1; i >= pos; i--)
	{
		arry->pAddr[i + 1] = arry->pAddr[i];
	}

	//4.插入
	arry->pAddr[pos] = data;

	arry->m_size++;  //更新数组大小
}

//遍历数组
void foreachDynamicArray(struct dynamicArray* arry, void(*myPrint)(void*))
{
	if (arry == NULL || myPrint == NULL)
	{
		return;
	}
	if (arry->m_size == 0)
	{
		return;
	}

	for (int i = 0; i < arry->m_size; i++)
	{
		myPrint(arry->pAddr[i]);
	}
}

//按位置删除数组元素
void removeByPosDynamicArray(struct dynamicArray* arry, int pos)
{
	//1.判断
	if (arry == NULL)
	{
		return;
	}
	if (arry->m_size == 0)
	{
		return;
	}
	if (pos < 0 || pos >= arry->m_size)
	{
		return;
	}

	//2. 删除, 向前覆盖
	for (int i = pos; i < arry->m_size - 1; i++)  //删除最后一个元素直接m_size--即可
	{
		arry->pAddr[i] = arry->pAddr[i + 1];
	}

	//3.更新
	arry->m_size--;
}

//按值删除
void removeByValueDynamicArray(struct dynamicArray* arry, void* data, int(*myCompare)(void*, void*))
{
	//1.判断
	if (arry == NULL || data == NULL || myCompare == NULL)
	{
		return;
	}
	if (arry->m_size == 0)
	{
		return;
	}

	//2.删除
	for (int i = 0; i < arry->m_size; i++)
	{
		if (myCompare(arry->pAddr[i], data))
		{
			//如果找到要删除的数据，i就是要删除的具体位置
			removeByPosDynamicArray(arry, i);
			break;  //只删除第一次出现的
		}
	}

	//3.更新,removeByPosDynamicArray中已经更新过了
}

//销毁数组
void destroyDynamicArray(struct dynamicArray* arry)
{
	if (arry == NULL)
	{
		return;
	}

	//先销毁属性的指针，再销毁结构体指针
	if (arry->pAddr != NULL)
	{
		free(arry->pAddr);
		arry->pAddr = NULL;
	}
	free(arry);
	arry = NULL;
}
//seq_queue.c

#include "seq_queue.h"

//初始化
SeqQueue initSeqQueue()
{
	struct dynamicArray* arry = (struct dynamicArray*)initDynamicArray(MAX);
	return arry;
}

//出队
void popSeqQueue(SeqQueue queue)
{
	if (queue == NULL)
	{
		return;
	}

	struct dynamicArray* myqueue = (struct dynamicArray*)queue;
	if (myqueue->m_size <= 0)
	{
		return;
	}
	removeByPosDynamicArray(myqueue, 0);  //本质是头删
}

//入队
void pushSeqQueue(SeqQueue queue, void* data)
{
	if (queue == NULL || data == NULL)
	{
		return;
	}

	struct dynamicArray* myqueue = (struct dynamicArray*)queue;
	if (myqueue->m_size == MAX)
	{
		return;
	}

	insertDynamicArray(myqueue, myqueue->m_size, data);  //本质是尾插
}

//返回队列大小
int sizeSeqQueue(SeqQueue queue)
{
	if (queue == NULL)
	{
		return NULL;
	}

	struct dynamicArray* myqueue = (struct dynamicArray*)queue;
	return myqueue->m_size;
}

//判断队列是否为空
int isEmptySeqQueue(SeqQueue queue)
{
	if (queue == NULL)
	{
		return NULL;
	}

	struct dynamicArray* myqueue = (struct dynamicArray*)queue;
	if (myqueue->m_size == 0)
	{
		return 1;
	}
	return 0;
}

//返回队头元素
void* frontSeqQueue(SeqQueue queue)
{
	if (queue == NULL)
	{
		return NULL;
	}

	struct dynamicArray* myqueue = (struct dynamicArray*)queue;
	return myqueue->pAddr[0];
}

//返回队尾元素
void* backSeqQueue(SeqQueue queue)
{
	if (queue == NULL)
	{
		return NULL;
	}

	struct dynamicArray* myqueue = (struct dynamicArray*)queue;
	return myqueue->pAddr[myqueue->m_size-1];
}


//销毁队列
void destroySeqQueue(SeqQueue queue)
{
	if (queue == NULL)
	{
		return;
	}

	struct dynamicArray* myqueue = (struct dynamicArray*)queue;
	destroyDynamicArray(myqueue);
}

//test.c

#include "seq_queue.h"

//自定义类型
struct Person
{
	char name[64];
	int age;
};

int main()
{
	SeqQueue* myqueue = initSeqQueue();

	struct Person p1 = { "san", 11 };
	struct Person p2 = { "si", 22 };
	struct Person p3 = { "wu", 33 };
	struct Person p4 = { "wu", 33 };

	pushSeqQueue(myqueue, &p1);
	pushSeqQueue(myqueue, &p2);
	pushSeqQueue(myqueue, &p3);
	pushSeqQueue(myqueue, &p4);

	printf("queue size:%d\n", sizeSeqQueue(myqueue));

	while (!isEmptySeqQueue(myqueue))
	{
		struct Person* pFront = frontSeqQueue(myqueue);
		printf("front:name[%s]  age[%d]\n", pFront->name, pFront->age);

		struct Person* pBack = backSeqQueue(myqueue);
		printf("back:name[%s]  age[%d]\n", pBack->name, pBack->age);

		popSeqQueue(myqueue);
	}
	printf("queue size:%d\n", sizeSeqQueue(myqueue));

	return 0;
}

>>> 队列的链式存储

//link_queue.h

#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

//定义企业版链表节点结构体
struct QueueNode
{
	struct QueueNode* next;
};

//队列结构体
struct LQueue
{
	struct QueueNode pHeader;
	int m_size;
	struct QueueNode* pTail;  //尾节点指针，因为队列尾部需要频繁插入
};

typedef void* LinkQueue;

//初始化队列
LinkQueue initLinkQueue();
//出队
void popLinkQueue(LinkQueue queue);
//入队
void pushLinkQueue(LinkQueue queue, void* data);
//返回队列大小
int sizeLinkQueue(LinkQueue queue);
//判断队列是否为空
int isEmptyLinkQueue(LinkQueue queue);
//返回队头元素
void* frontLinkQueue(LinkQueue queue);
//返回队尾元素
void* backLinkQueue(LinkQueue queue);
//销毁队列
void destroyLinkQueue(LinkQueue queue);
//link_queue.c

#include "link_queue.h"

//初始化队列
LinkQueue initLinkQueue()
{
	struct LQueue* myQueue = (struct LQueue*)malloc(sizeof(struct LQueue));
	if (myQueue == NULL)
	{
		return NULL;
	}

	myQueue->pHeader.next = NULL;
	myQueue->m_size = 0;
	myQueue->pTail = &myQueue->pHeader;  //开始时尾节点指针指向头节点
	return myQueue;
}

//出队
void popLinkQueue(LinkQueue queue)
{
	if (queue == NULL)
	{
		return;
	}

	struct LQueue* myQueue = (struct LQueue*)queue;
	if (myQueue->m_size == 0)
	{
		return;
	}
	if (myQueue->m_size == 1)
	{
		myQueue->pHeader.next = NULL;
		myQueue->pTail = &myQueue->pHeader;  //1个节点的时候，要将尾节点还原到头
		myQueue->m_size--;
		return;
	}

	struct QueueNode* pDel = myQueue->pHeader.next;
	myQueue->pHeader.next = pDel->next;
	myQueue->m_size--;
}

//入队
void pushLinkQueue(LinkQueue queue, void* data)
{
	if (queue == NULL || data == NULL)
	{
		return;
	}

	struct LQueue* myQueue = (struct LQueue*)queue;
	struct QueueNode* newNode = (struct QueueNode*)data;

	newNode->next = NULL;
	myQueue->pTail->next = newNode;  //更改指针指向
	myQueue->pTail = newNode;  //更新新的尾节点
	myQueue->m_size++;

}

//返回队列大小
int sizeLinkQueue(LinkQueue queue)
{
	if (queue == NULL)
	{
		return NULL;
	}

	struct LQueue* myQueue = (struct LQueue*)queue;
	return myQueue->m_size;
}

//判断队列是否为空
int isEmptyLinkQueue(LinkQueue queue)
{
	if (queue == NULL)
	{
		return NULL;
	}

	struct LQueue* myQueue = (struct LQueue*)queue;
	if (myQueue->m_size == 0)
	{
		return 1;
	}
	return 0;
}

//返回队头元素
void* frontLinkQueue(LinkQueue queue)
{
	if (queue == NULL)
	{
		return NULL;
	}

	struct LQueue* myQueue = (struct LQueue*)queue;
	return myQueue->pHeader.next;
}

//返回队尾元素
void* backLinkQueue(LinkQueue queue)
{
	if (queue == NULL)
	{
		return NULL;
	}

	struct LQueue* myQueue = (struct LQueue*)queue;
	return myQueue->pTail;
}

//销毁队列
void destroyLinkQueue(LinkQueue queue)
{
	if (queue == NULL)
	{
		return;
	}

	free(queue);
	queue = NULL;
}

 

//test.c

#include "link_queue.h"

//自定义类型
struct Person
{
	void* node;
	char name[64];
	int age;
};


int main()
{
	LinkQueue myqueue = initLinkQueue();

	struct Person p1 = {NULL, "san", 11 };
	struct Person p2 = {NULL, "si", 22 };
	struct Person p3 = {NULL, "wu", 33 };
	struct Person p4 = {NULL, "wu", 33 };

	pushLinkQueue(myqueue, &p1);
	pushLinkQueue(myqueue, &p2);
	pushLinkQueue(myqueue, &p3);
	pushLinkQueue(myqueue, &p4);

	printf("queue size:%d\n", sizeLinkQueue(myqueue));

	while (!isEmptyLinkQueue(myqueue))
	{
		struct Person* pFront = frontLinkQueue(myqueue);
		printf("front:name[%s]  age[%d]\n", pFront->name, pFront->age);

		struct Person* pBack = backLinkQueue(myqueue);
		printf("back:name[%s]  age[%d]\n", pBack->name, pBack->age);

		popLinkQueue(myqueue);
	}
	printf("queue size:%d\n", sizeLinkQueue(myqueue));

	return 0;
}

SDTyuan
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
数据结构---队列及其应用
CS专业追想日记
10-08 1467
实验目录一、实验目的二、实验内容三、实验步骤四、实验代码一、队列的定义二、算法的初始化和实现五、总结 一、实验目的 1.掌握队列的基本概念、基本操作和基本使用方式。 2.掌握循环队列的类型定义以及实现方法。 3.掌握循环队列的基本操作:初始化、入队、出队、队空判断、获取队头元素。 4.掌握循环队列的实现和简单应用。 5.能够清楚理解循环队列中空间的重用思想。 二、实验内容 1.设计和实现一个队列数据结构,且采用循环队列实现方法。 2.实现循环队列的各种操作,包括循环队列的初始化、出入队、清空和释放等。 3.
数据结构-队列的实现代码（C语言版）.rar
10-27
数据结构 -- C语言版 -- 队列的部分实现代码，详细介绍参考数据结构--队列的系列博文。链接为：https://blog.csdn.net/songshuai0223/category_9742561.html。
数据结构 -- 队列
weixin_48084293的博客
08-30 8009
文章目录什么是队列队列的顺序存储方式循环队列代码实现循环队列的顺序存储结构判断队列是否已满判断队列是否为空向队列中添加元素删除队列中的元素获取队头元素获取队列元素个数遍历元素整体代码 什么是队列 队列（queue）是只允许在一端进行插入操作，而另一端进行删除操作的线性表结构。 队列是一种先进先出的(First In First Out)的线性表，简称FIFO，允许插入的一段称为队尾，允许删除的一段称为队头。 假设存在队列 q=(a1,a2,a3…an)， 则a1为队头元素，an为队尾元素，删除时总是删除
C语言数据结构-队列
Flin
03-13 2769
队列的特征： 特殊的线性表，先进先出(FIFO) (1)数据：对于非空的队列，表头没有直接前驱，表尾没有直接后继，其他有且仅有一个直接前驱和一个直接后继。 (2)操作：只允许在表尾插入数据，在表头删除数据 ...
数据结构 - 循环队列
Sun_candong的博客
08-09 1344
线性数据结构-循环队列
数据结构-队列
weixin_45666566的博客
04-18 4882
队列一.定义二.特点三.时间复杂度四.基本运算队列的顺序存储 一.定义 队列（queue）是一种先进先出的线性表，简称FIFO。在表一端（表尾）插入，在另一端（表头）删除。 二.特点 1）在表一端（表尾）插入，在另一端（表头）删除的线性表。 2）表的插入操作称为入队，表的取出操作称为出队。 3）队列的存储结构分为顺序存储或链式，存储顺序存储称为顺序队，链式存储称为链队。以循环顺序队列更常见。 4）...
数据结构 - 链式队列
weixin_49303682的博客
12-26 2872
1.链式队列 链式队列 ： 用链表形式实现的队列。链表结点为队列数据存储区，链表结点包括两部分数据存储 区和指针存储区。 数据存储区 ：存放真实有效数据的区域。 指针存储区 ：存放下一个链表结点的地址。 2.创建链式队列 为链式队列申请内存，即为队首指针和队尾指针申请内存。 为链式队列头结点申请内存，头结点不存放有效数据，方便队列的操作。 将队首指针和队尾指针指向头结点，即队首指针和队尾指针相等。 链式队列头结点指针域为空，即为NULL；头结点数据域可不管，亦可为零，作为链式队列有效的
嵌入式常用数据结构------队列操作简介
08-21
队列是一种特殊的数据结构，它遵循“先进先出”（First In First Out，简称FIFO）的原则，类似于现实生活中的排队购票场景。在嵌入式软件开发中，队列被广泛应用于处理顺序执行的任务，例如任务调度、数据传输、消息...
数据结构-循环队列-C语言实现循环队列-数据结构学习
05-27
C语言实现的数据结构中的循环队列 包含源码（.c文件），linux环境下编译生成的可执行文件，头文件，以及测试用的main.c文件 用于C语言以及数据结构的学习 循环队列的.c和.h文件实现了以下功能： 创建循环队列 入队列...
数据结构--队列--思维导图.pdf
08-29
数据结构--队列--思维导图.pdf 数据结构中，队列（Queue）是一种重要的抽象数据类型，具有重要的应用价值。队列是一种特殊的线性表，它只允许在一端进行插入，另一端进行删除。队列的基本概念和操作将在下面详细...
C++笔记18•数据结构:AVL树•
qq_64446190的博客
09-06 304
AVL树
栈—数据结构
weixin_63722559的博客
09-06 708
6、获取栈顶元素（获取栈顶元素，在外面开一个空间，将该空间的地址传过去，进行获取元素，以便于区分元素还是返回值）入栈的方向是是增栈的方式，放入数据的是满栈的方式。入栈的方向是是减栈的方式，放入数据的是满栈的方式。入栈的方向是是增栈的方式，放入数据的是空栈的方式。入栈的方向是是减栈的方式，放入数据的是空栈的方式。3、出栈（看一下，出去的元素，所以和6一样）1、入栈：先放入输入，再移动栈顶指针。2、出栈：先移动栈顶指针，再数据弹出。1、入栈：先挪栈顶指针，再放入数据。2、出栈：先移出数据，再移动指针。
【数据结构-二维前缀和】力扣1277. 统计全为 1 的正方形子矩阵
sjsjs11的博客
09-06 158
该题和力扣221.最大正方形类似，以某一格为右下角能形成最大正方形的边长，就是以该格为右下角的正方形数量。给你一个 m * n 的矩阵，矩阵中的元素不是 0 就是 1，请你统计并返回其中完全由 1 组成的 正方形 子矩阵的个数。正方形的总数 = 10 + 4 + 1 = 15.正方形的总数 = 6 + 1 = 7.边长为 1 的正方形有 10 个。边长为 2 的正方形有 4 个。边长为 3 的正方形有 1 个。边长为 1 的正方形有 6 个。边长为 2 的正方形有 1 个。输入：matrix =
数据结构之“双向链表”
2402_83250773的博客
09-06 625
双向链表，顺序表与链表的比较
数据结构：（LeetCode203）移除链表元素
2303_81073778的博客
09-06 187
请你删除链表中所有满足。给你一个链表的头节点。
嵌入式初学-C语言-数据结构--四
MaBaB的博客
09-06 463
栈是一种逻辑结构，是特殊的线性表。特殊在：只能在固定的一端操作只要满足上述条件，那么这种特殊的线性表就会呈现一种“后进先出”的逻辑，这种逻辑就被称为栈。栈 在生活中到处可见，比如堆叠的盘子、电梯中的人们、嵌套函数的参数等等。由于约定了只能在线性表固定的一端进行操作，于是给栈这种特殊的线性表的“插入”、“删除”，另起了 下面这些特定的名称：栈顶：可以进行插入删除的一端栈底：栈顶的对端入栈：将节点插入栈顶之上，也称为压栈，函数名通常为push()
数据结构 栈 队列
qq_69971969的博客
09-06 464
数据的插入--->入栈 数据的删除----->出栈。函数的调用关系（保护现场，恢复现场操作，遵循先进后出，后进先出）缓存数据：主要使用队列，类似于缓冲区，防止数据丢失。允许从一端插入数据，另一端删除数据的线性存储结构。只允许从一端进行数据的插入和删除的线性存储结构。增栈 减栈：用栈顶的增长方向区分（移动方向）顺序队列：假溢出------>循环队列。满栈 空栈：栈顶所在位置是否存有元素。增栈：从内存低地址向高地址移动。减栈：从内存高地址向低地址移动。链式队列：用链表方式构造队列。
数据结构————栈、队列
qq_63843346的博客
09-06 421
在使用数组实现的队列中，如果队列的尾部已经到达数组的末尾，但数组的前部仍有空闲空间，此时队列将无法继续入队，产生假溢出。：特别是在使用数组实现的队列中，如果队列的长度远小于数组的长度，那么数组的大部分空间将被浪费。：虽然队列的遍历通常比栈更简单（因为不需要额外的空间来保存遍历过程中的元素），但在某些情况下（如需要频繁遍历队列），队列的遍历效率可能不是最优的。即最早插入队列的元素将会是第一个被移除的。：栈的遍历通常需要额外的空间来保存遍历过程中的元素，因为栈的后进先出特性使得遍历过程与元素的自然顺序相反。
数据结构-----栈、队列
最新发布
2301_77841194的博客
09-06 147
1、栈(stack)是限定仅在表尾进行插入和删除操作的线性表。把允许插入和删除的一端称为栈顶（top)，另一端称为栈底（bottom)，不含任何数据元素的栈称为空栈。栈又称为后进先出（Last In First Out)的线性表,简称LIFO结构。2、栈的插入操作：叫作进栈,也称压栈、入栈示。栈的删除操作：叫作出栈,也有的叫作弹栈。满栈、空栈：栈顶所在位置是否存有元素增栈、减栈：栈的增长方向。
数据结构-循环队列详解
"循环队列臆造-河南大学数据结构课件（清华版）" 循环队列是一种在计算机科学中广泛使用的数据结构，它在顺序存储结构的基础上进行扩展，解决了传统队列在满和空状态下的判断二义性问题。在循环队列中，元素在数组...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值