【数据结构与算法】受限线性表-队列

于 2024-09-14 22:20:00 发布
阅读量310 收藏 10
点赞数 4
分类专栏： 数据结构与算法 文章标签： C语言 数据结构 队列 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80035097/article/details/142227674
版权

系列文章目录

文章目录

前言

本篇文章将讲到队列的基本概念，队列的顺序存储，以及队列的链式存储。

一、队列的基本概念

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

队列是一种先进先出的t（First In First Out）的线性表，简称FIFO。允许插入的一端为队尾，允许删除的一端为队头。队列不允许在中间部位进行操作！假设队列是q=（a1，a2，……，an），那么a1就是队头元素，而an是队尾元素。这样我们就可以删除时，总是从a1开始，而插入时，总是在队列最后。这也比较符合我们通常生活中的习惯，排在第一个的优先出列，最后来的当然排在队伍最后。
在这里插入图片描述

二、队列的顺序结构

  • dynamicArray.h
#pragma  once
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
#include<stdlib.h>


//动态数组结构体
struct dynamicArray
{
	void ** pAddr; //维护真实在堆区创建的数组的指针

	int m_capacity;  // 数组容量

	int m_size;   //数组大小
};

//初始化数组
struct dynamicArray * init_DynamicArray(int capacity);

//插入数组
void insert_DynamicArray(struct dynamicArray * array, int pos, void * data);


//遍历数组
void foreach_DynamicArray(struct dynamicArray * array, void(*myPrint)(void*));


//删除数组  按位置删除
void removeByPos_DynamicArray(struct dynamicArray * array, int pos);

//按值删除数据
void removeByValue_DynamicArray(struct dynamicArray * array, void * data, int(*myCompare)(void *, void *));


//销毁数组
void destroy_DynamicArray(struct dynamicArray* array);
  • seqQueue.h
#pragma once
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include "dynamicArray.h"
#define  MAX  1024

typedef void* seqQueue;

//初始化队列
seqQueue init_SeqQueue();
//入队
void push_SeqQueue(seqQueue queue, void* data);
//出队
void pop_SeqQueue(seqQueue queue);
//返回队列大小
int size_SeqQueue(seqQueue queue);
//判断队列是否为空
int isEmpty_SeqQueue(seqQueue queue);
//返回队头元素
void* front_SeqQueue(seqQueue queue);
//返回队尾元素
void* back_SeqQueue(seqQueue queue);
//销毁队列
void destroy_SqeqQueue(seqQueue queue);
  • dynamicArray.c
#include "dynamicArray.h"


//初始化数组
struct dynamicArray * init_DynamicArray(int capacity)
{
	if (capacity <= 0)
	{
		return NULL;
	}

	//给数组分配空间

	struct dynamicArray * array = malloc(sizeof(struct dynamicArray));
	if (array == NULL)
	{
		return NULL;
	}

	//给数组初始化
	array->pAddr = malloc(sizeof(void *)* capacity);
	array->m_capacity = capacity;
	array->m_size = 0;

	return array;
}

//插入数组
void insert_DynamicArray(struct dynamicArray * array, int pos, void * data)
{
	if (array == NULL)
	{
		return;
	}
	if (data == NULL)
	{
		return;
	}

	//无效位置  尾插
	if (pos < 0 || pos > array->m_size)
	{
		pos = array->m_size;
	}

	//判断是否满了，如果满动态扩展
	if (array->m_size == array->m_capacity)
	{
		//1、计算新空间大小
		int newCapacity = array->m_capacity * 2;

		//2、创建新空间
		void ** newSpace = malloc(sizeof(void *)* newCapacity);

		//3、将原有数据拷贝到新空间下
		memcpy(newSpace, array->pAddr, sizeof(void *)* array->m_capacity);

		//4、释放原有内存空间
		free(array->pAddr);

		//5、更新新空间指向
		array->pAddr = newSpace;

		//6、更新新容量
		array->m_capacity = newCapacity;
	}

	//插入新元素

	//移动元素 进行插入新元素
	for (int i = array->m_size - 1; i >= pos; i--)
	{
		//数据向后移动
		array->pAddr[i + 1] = array->pAddr[i];
	}

	//将新元素 插入到指定位置上
	array->pAddr[pos] = data;
	//更新大小
	array->m_size++;
}


//遍历数组
void foreach_DynamicArray(struct dynamicArray * array, void(*myPrint)(void*))
{
	if (array == NULL)
	{
		return;
	}
	if (myPrint == NULL)
	{
		return;
	}

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


//删除数组  按位置删除
void removeByPos_DynamicArray(struct dynamicArray * array, int pos)
{
	if (NULL == array)
	{
		return;
	}

	if (pos < 0 || pos > array->m_size - 1)
	{
		return;
	}

	//数据前移
	for (int i = pos; i < array->m_size - 1; i++)
	{
		array->pAddr[i] = array->pAddr[i + 1];
	}

	//更新数组大小
	array->m_size--;

}

//按值删除数据
void removeByValue_DynamicArray(struct dynamicArray * array, void * data, int(*myCompare)(void *, void *))
{
	if (array == NULL)
	{
		return;
	}
	if (data == NULL)
	{
		return;
	}

	for (int i = 0; i < array->m_size; i++)
	{
		if (myCompare(array->pAddr[i], data))
		{
			//如果找到要删除的数据，i就是要删除的具体位置
			removeByPos_DynamicArray(array, i);
			break;
		}
	}

}

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

	if (array->pAddr != NULL)
	{
		free(array->pAddr);
		array->pAddr = NULL;
	}


	free(array);
	array = NULL;
}
  • seqQueue.c

#include "seqQueue.h"

//初始化队列
seqQueue init_SeqQueue()
{
	struct dynamicArray* arr = init_DynamicArray(MAX);

	return arr;
}

//入队
void push_SeqQueue(seqQueue queue, void* data)
{
	//本质   尾插
	if (queue == NULL)
	{
		return;
	}
	if (data == NULL)
	{
		return;
	}
	struct dynamicArray* myQueue = queue;

	if (myQueue->m_size == MAX)
	{
		return;
	}

	insert_DynamicArray(myQueue, myQueue->m_size, data);

}

//出队
void pop_SeqQueue(seqQueue queue)
{
	// 本质   头删
	if (queue == NULL)
	{
		return;
	}

	struct dynamicArray* myQueue = queue;

	if (myQueue->m_size <= 0)
	{
		return;
	}
	removeByPos_DynamicArray(myQueue, 0);
}

//返回队列大小
int size_SeqQueue(seqQueue queue)
{
	if (queue == NULL)
	{
		return -1;
	}
	struct dynamicArray* myQueue = queue;

	return myQueue->m_size;

}

//判断队列是否为空
int isEmpty_SeqQueue(seqQueue queue)
{
	if (queue == NULL)
	{
		return -1;
	}

	struct dynamicArray* myQueue = queue;

	if (myQueue->m_size == 0)
	{
		return 1;
	}
	return 0;

}

//返回队头元素
void* front_SeqQueue(seqQueue queue)
{
	if (queue == NULL)
	{
		return NULL;
	}
	struct dynamicArray* myQueue = queue;

	return myQueue->pAddr[0];
}

//返回队尾元素
void* back_SeqQueue(seqQueue queue)
{
	if (queue == NULL)
	{
		return NULL;
	}
	struct dynamicArray* myQueue = queue;

	return myQueue->pAddr[myQueue->m_size - 1];
}

//销毁队列
void destroy_SeqQueue(seqQueue queue)
{
	if (queue == NULL)
	{
		return;
	}
	destroy_DynamicArray(queue);
}
  • 队列顺序存储.c
#include "seqQueue.h"

struct Person
{
	char name[64];
	int age;
};

void test01()
{
	//初始化队列
	seqQueue myQueue = init_SeqQueue();

	//准备数据
	struct Person p1 = { "aaa", 10 };
	struct Person p2 = { "bbb", 20 };
	struct Person p3 = { "ccc", 30 };
	struct Person p4 = { "ddd", 40 };
	//入队
	push_SeqQueue(myQueue, &p1);
	push_SeqQueue(myQueue, &p2);
	push_SeqQueue(myQueue, &p3);
	push_SeqQueue(myQueue, &p4);
	printf("队列大小为：%d\n", size_SeqQueue(myQueue));

	while (isEmpty_SeqQueue(myQueue) == 0)
	{
		//访问队头
		struct Person* pFront = front_SeqQueue(myQueue);
		printf("队头元素 -- 姓名：%s  年龄： %d\n", pFront->name, pFront->age);
		//访问队尾
		struct Person* pBack = back_SeqQueue(myQueue);
		printf("队尾元素 -- 姓名：%s  年龄： %d\n", pBack->name, pBack->age);
		//出队
		pop_SeqQueue(myQueue);
	}

	printf("队列大小为：%d\n", size_SeqQueue(myQueue));

	//销毁队列
	destroy_SeqQueue(myQueue);
}

int main() {
	test01();


	system("pause");
	return EXIT_SUCCESS;
}

三、队列的链式存储

linkQueue.h

#pragma once
#define  _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<string.h>
#include<stdlib.h>

// 结点结构体
struct QueueNode
{
	struct QueueNode* next;
};

//队列结构体
struct LQueue
{
	struct QueueNode pHeader;
	int m_size;
	struct QueueNode* pTail;
};

typedef void* LinkQueue;


//初始化队列
LinkQueue init_LinkQueue();
//入队
void push_LinkQueue(LinkQueue queue, void* data);
//出队
void pop_LinkQueue(LinkQueue queue);
//返回队列大小
int size_LinkQueue(LinkQueue queue);
//判断是否为空
int isEmpty_LinkQueue(LinkQueue queue);
//返回队头
void* front_LinkQueue(LinkQueue queue);
//返回队尾
void* back_LinkQueue(LinkQueue queue);
//销毁队列
void destroy_LinkQueue(LinkQueue queue);

linkQueue.c

#include "linkQueue.h"

//初始化队列
LinkQueue init_LinkQueue()
{
	struct LQueue* myQueue = malloc(sizeof(struct LQueue));
	if(myQueue == NULL)
	{
		return NULL;
	}
	myQueue->pHeader.next = NULL;
	myQueue->m_size = 0;

	myQueue->pTail = &myQueue->pHeader;

	return myQueue;
}

//入队
void push_LinkQueue(LinkQueue queue, void* data)
{
	if (queue == NULL)
	{
		return;
	}
	if (data == NULL)
	{
		return;
	}
	//本质 尾插
	struct LQueue* myQueue = queue;
	struct QueueNode* myNode = data;

	//更新指针指向
	myQueue->pTail->next = myNode;
	myNode->next = NULL;

	//更新新的尾结点
	myQueue->pTail = myNode;
	myQueue->m_size++;
}

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

	struct LQueue* myQueue = queue;

	//本质 头删

	if (myQueue->m_size == 0)
	{
		return;
	}

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

	//记录第一个有数据的节点
	struct QueueNode* pFirst = myQueue->pHeader.next;

	//更改指针指向
	myQueue->pHeader.next = pFirst->next;
	myQueue->m_size--;
}

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

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

//判断是否为空
int isEmpty_LinkQueue(LinkQueue queue)
{
	if (queue == NULL)
	{
		return -1;
	}
	struct LQueue* myQueue = queue;
	if (myQueue->m_size == 0)
	{
		return 1;
	}
	return 0;
}

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

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

//返回队尾
void* back_LinkQueue(LinkQueue queue)
{
	if (queue == NULL)
	{
		return NULL;
	}
	struct LQueue* myQueue = queue;
	return myQueue->pTail;
}

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

队列的链式存储

#include "linkQueue.h"

struct Person
{
	void* node;
	char name[64];
	int age;
};

void test01()
{
	//初始化队列
	LinkQueue myQueue = init_LinkQueue();

	//准备数据
	struct Person p1 = { NULL, "aaa", 10 };
	struct Person p2 = { NULL, "bbb", 20 };
	struct Person p3 = { NULL, "ccc", 30 };
	struct Person p4 = { NULL, "ddd", 40 };
	struct Person p5 = { NULL, "eee", 50 };

	//入队
	push_LinkQueue(myQueue, &p1);
	push_LinkQueue(myQueue, &p2);
	push_LinkQueue(myQueue, &p3);
	push_LinkQueue(myQueue, &p4);
	push_LinkQueue(myQueue, &p5);
	printf("队列大小为：%d\n", size_LinkQueue(myQueue));
	while (isEmpty_LinkQueue(myQueue) == 0)
	{
		//访问队头
		struct Person* pFront = front_LinkQueue(myQueue);
		printf("链式存储::队头元素 -- 姓名：%s  年龄： %d\n", pFront->name, pFront->age);
		//访问队尾
		struct Person* pBack = back_LinkQueue(myQueue);
		printf("链式存储::队尾元素 -- 姓名：%s  年龄： %d\n", pBack->name, pBack->age);
		//出队
		pop_LinkQueue(myQueue);
	}

	printf("队列大小为：%d\n", size_LinkQueue(myQueue)); 

	//销毁队列
	destroy_LinkQueue(myQueue); 
}


int main() {

	test01();

	system("pause");
	return EXIT_SUCCESS;
}

总结

到这里这篇文章的内容就结束了，谢谢大家的观看，如果有好的建议可以留言喔，谢谢大家啦！

冷白白
关注
专栏目录
使用Python实现队列
iwantoseeu的博客
03-18 2089
了解‘生产者/消费者’模型 在餐馆吃饭时，厨师做完一道菜后就会把菜从传菜递出去，然后继续做下一道菜。厨师不需要关心顾客是不是已经把菜吃完了。如果厨师做菜的速度大于顾客拿菜的速度，那么就会有越来越多的菜堆在传菜窗口。如果顾客拿菜的速度大于厨师做菜的速度，那么传菜窗口始终都是空的，来一道菜就会立刻被拿走。 在程序开发中，这就是一个典型的“生产者/消费者”模型：厨师是生产者，负责生产；顾客是消费者，负责消费。厨师和顾客各做各的。传菜口就是队列，它把生产者和消费者联系在一起。 实例描述： 使用pytho
python实现数据结构（五）——队列实现
Star_Platinum的博客
08-17 520
队列简介 队列（queue）是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。 队列是一种先进先出的（First In First Out）的线性表，简称FIFO。允许插入的一端为队尾，允许删除的一端为队头。队列不允许在中间部位进行操作！假设队列是q=（a1，a2，……，an），那么a1就是队头元素，而an是队尾元素。这样我们就可以删除时，总是从a1开始，而插入时，总是在队列最后。这...
数据结构与算法——Java数组实现环形队列（尾部下一位置为空作为标记）
YueYingGuang的博客
12-29 409
数据结构与算法——Java数组实现环形队列 通过数组的方式实现环形队列 1、front、rear初始为0，front直接指向头部，rear直接指向尾部，rear的下一个位置为空，作为队列是否满的标记。 2、队列是否满的条件：(rear + 1) % maxSize == front 3、队列是否为空的条件：rear == front 4、有效数据的计算方式：(rear + maxSize - ...
python——数据结构之队列
Cherry的博客
04-30 404
class Queue(object): """队列""" def __init__(self): self.items = [] def is_empty(self): return self.items == [] def enqueue(self, item): """进队列""" self...
队列的实现
weixin_42417337的博客
06-27 226
链式队列的过程分析与实现一、队列的组成概念部分：链式队列是一个先进先出的由链表指针链接的动态内存。队列的实现有两种：基于数组的队列和机遇链表的队列，但是要注意的是基于数组的队列必须是循环队列才可以，因为要节省内存。链式队列的组成由两部分组成的：结点(node)和指针(rear front),这两部分都是需要建立结构体实现的。二、操作实现部分1、结构体的建立： 结点部分的结构体建立：typ...
数据结构与算法基础---栈和队列
puzzleZHOU的博客
03-27 710
栈和队列前言1 栈和队列的定义和特点1.1 栈的定义和特点1.2 队列的定义和特点2 案例引入3 栈的表示和操作的实现3.1 栈的抽象数据类型的类型定义3.2 顺序栈的表示和实现3.3 链栈的表示和实现4 栈与递归5 队列的表示和操作的实现5.1 队列的抽象数据类型定义5.2 队列的顺序表示和实现 前言 本章的内容并不难，重点需要理解的是栈和队列是操作受限的线性表，是在前一章线性表的基础上增加了一些约束条件。另外本章涉及到递归的概念，这个在后面章节有更多的应用，一定要重点理解掌握~ 1 栈和队列的定义和
数据结构与算法学习笔记-栈和队列
qq_53548177的博客
12-10 1172
声明：本博客仅为本人学习途中做的笔记 采自青岛大学王卓老师的视频教学 主要内容为算法思路，具体代码实现还需修改后才能运行，望各位看官多多包涵，您的点赞与评论是对我最大的肯定！ 1.栈和队列的定义和特点 栈和队列是两种常用的、重要的数据结构 栈和队列是限定插入和删除只能在表的"端点"进行的线性表 栈和队列是线性表的子集(是插入和删除位置受限的线性表) 由于栈的操作具有后进先出的固有特性，使得栈成为程序设计中的有用工具。另外，如果问题求解的过程具有"后进先出"的天然特性的话，则求解的算法中也必然需要利用.
数据结构--队列--js击鼓传花算法实现
咩羊的博客
07-26 441
击鼓传花游戏 原游戏规则： 班级中玩一个游戏，所有学生围成一圈，从某位同学手里开始向旁边的同学传一束花。 这个时候某个人（比如班长），在击鼓，鼓声停下的一刻，花落在谁手里，谁就出来表演节目 一般在编程中就会把游戏规则修改一点 修改后的游戏规则： 几个朋友一起玩一个游戏，围成一圈，开始数数，数到某个数字的人自动淘汰。 最后剩下的这个人会获得胜利，请问最后剩下的是原来在哪一个位置上的人？ 要想用JavaScript实现这个游戏，可以使用队列的知识 队列：一种受限的线性表，先进先出。它只允许在表的前端(f
数据结构与算法分析 收获总结 第4章 线性表，栈和队列
weixin_43937162的博客
11-18 396
这章开始就正式步入数据结构的大门了 1.ADT指的是抽象数据类型，这章多用它来先大体上定义一个数据类型 2.线性表（list），与之相关的两个重要概念：位置（position）,元素（element）。线性表是由称为元素的数据项组成的一种有限且有序的序列。有序指的是每一个元素都有自己的位置。 不含任何元素时，称为空表（empty list）。存储的元素数目称为线性表的长度（length），线性表的...
2023王道考研数据结构第三章---队列
weixin_52572034的博客
08-30 913
2023王道考研数据结构第三章---队列
在 Python 中使用队列
lei_qi的博客
09-05 1054
在 Python 中使用队列 在 Python 中，可以使用以下几种方法实现队列 collections包里的deque，对应操作 pop()从尾取出 appendleft() 从头插入 queue包中的queue，对应操作 put() 插入 get() 取出 直接使用list，只要保证只使用 pop() 取出 insert(0,) 插入 或者只使用 append() 插入 list[0]并且del list[0] 取出 两者使用list方法的不同就区别于你把哪个当头，哪个当尾 ...
数据结构（Python实现）------队列
Avery123123的博客
12-01 640
数据结构（Python实现）------ 队列数据结构（Python实现）------ 队列队列基本概念Python实现基本的队列双向队列 数据结构（Python实现）------ 队列 队列 基本概念 Python实现 基本的队列 class Queue(object): def __init__(self): self.data = [] def isEmp...
python 队列
最新发布
cliffordl的专栏
02-20 5362
Queue.qsize() 返回队列的大小Queue.empty() 如果队列为空，返回True,反之FalseQueue.full() 如果队列满了，返回True,反之False，Queue.full 与 maxsize 大小对应Queue.get([block[, timeout]])获取队列，timeout等待时间Queue.get_nowait() 相当于Queue.get(False)，非阻塞方法Queue.put(item) 写入队列，timeout等待时间。
python队列
weixin_53308294的博客
02-05 745
如果a线程需要向文件c写入"abc",b线程需要向文件c写入“123”.如果两个线程同时写入，那么就可能会写成a1b2c3,造成我们不想要的结果，如果有队列，a线程和b线程就会排队，依次写入自己的内容。多个线程中，线程中的变量各自是各自的，为了能够让多个线程之间共享某些数据，就可以使用队列来实现数据共享。先存入的会被先取出。优先级越高的越先取出。
python操作队列
Python热爱者的博客
08-01 3682
python操作队列
队列
yshir
11-15 233
队列（queue）是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。 队列是一种先进先出的（First In First Out）的线性表，简称FIFO。允许插入的一端为队尾，允许删除的一端为队头。队列不允许在中间部位进行操作！假设队列是q=（a1，a2，……，an），那么a1就是队头元素，而an是队尾元素。这样我们就可以删除时，总是从a1开始，而插入时，总是在队列最后。这也比较符合我们通常生活中的习惯，排在第一个的优先出列，最后来的当然排在队伍最后。 队列的实现 同栈一样，队列也可以用顺序
数据结构——队列及队列实现
swq 的博客
02-07 175
队列 队列： 先进先出(FIFO) JavaScript中没有队列，但可以用Array实现队列的所有功能。 入列 enqueue 出列 dequeue 查看列头 front 对应操作：push shift queue[0] 队列的实现 var Queue = function() { var items = [] // 入队 this.enqueue = function(element) { items.push(element)
Python队列的实现
分享一点有用的知识
04-23 461
Python队列的实现
python-Queue队列的实现原理
顾鸢的博客
09-06 1262
队列(Queue)-简介 队列（queue）是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。 队列是一种先进先出的（First In First Out）的线性表，简称FIFO。允许插入的一端为队尾，允许删除的一端为队头。队列不允许在中间部位进行操作！ 假设队列是q=（a1，a2，……，an），那么a1就是队头元素，而an是队尾元素。这样我们就可以删除时，总是从a1开始，而插入时，总是...
数据结构详解：线性表、栈、堆、队列与树
本脑图涵盖了多种数据结构，包括非受限线性表、顺序结构、链式结构、栈、堆、队列、二叉树以及排序算法等。" 在数据结构中，线性表是一种基础结构，它可以分为受限线性和非受限线性。顺序结构如数组是线性表的一种...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值