数据结构初阶：实现队列的两种方法

已于 2024-08-10 13:26:55 修改
阅读量370 收藏 12
点赞数 8
文章标签： 数据结构
于 2024-08-10 12:42:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jjj_mmm/article/details/141082223
版权

目录

  • 队列
    • 1队列的概念和两种实现方式
    • 2两种方式的具体方法
    • 3源代码
    • 4总结

队列

队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出
FIFO(First In First Out) 入队列：进行插入操作的一端称为队尾 出队列：进行删除操作的一端称为队头.
注意和栈的先进后出有所不同。
在这里插入图片描述

1队列的概念和两种实现方式

我们在实现栈的时候有
循环队列和链表队列两种方法。链表队是要用到两个结构体。一个结构体来存放数据，另一个结构体存放第一个结构体的指针然后用第二个结构体的指针来访问第一个结构体的指针和地址。这样做的好处是可以避免使用二级指针，进而优化算法。（因为在出队的时候要改变头指针的指向，但是形参不能改变实参，所以麻烦的方法是使用二级指针，然后解引用操作来改变头指针的地址，以达到出队的目的）。

typedef int SLType;
typedef struct SList
{
	struct SList* next;
	SLType val;
}Queue;

typedef struct Tool {
	Queue *ptail;
	Queue *head;
	int sum;
}Tool;  //链表队列

循环队列则是先定义一个最大的空间，然后出队是删除前面的元素，入队是在前面添加新元素。我们可以循环起来利用。
那么有个问题就是我们如何判断循环队列已经满了？

我们常见的方法就是牺牲一个空间，每次让Taii指向队尾元素下一个元素。然后用(Head+1)%N(N为元素空间)是否等于Head来判断。模N的目的是为了防止出界。
在这里插入图片描述如图我们有四个数据，虽然我们定义N是5但是只能存4个数据

2两种方式的具体方法

//初始化
//判断是否为满
//判断是否为空
//入队
//出队
//打印现有队列
//返回头元素
//返回尾部元素
//销毁队列

二种方法的定义
判断是否为满

链表队列

无序判断

循环队列

bool Full(Queue* p) {


	return (p->tail + 1) % N == p->head;

}//判断是否为满

链表队列

typedef int SLType;
typedef struct SList
{
	struct SList* next;
	SLType val;
}Queue;

typedef struct Tool {
	Queue *ptail;
	Queue *head;
	int sum;
}Tool;  //链表队列

循环队列

#define N 30//给数组30个空间大小来存放到循环数组中
typedef int QueType;
typedef struct Queue
{
	QueType* a;
	int head;
	int tail;


}Queue;//定义结构体内部有数组，头指针和尾指针

判断是否为空

链表队列

bool Empty(Tool* aa) {

	return (aa->phead == NULL) && (aa->ptail == NULL);

}

循环队列

bool Empty(Queue* p) {

	return (p->head == 0) && (p->tail == 0);
}//判断是否为空

初始化

链表队列

void Inite(Tool *aa)
{
	aa->phead = NULL;
	aa->ptail = NULL;
	aa->sum = 0;

}

循环队列

void Inite(Queue* p)
{
	p->a = NULL;
	p->head = 0;
	p->tail = 0;
	p->a = (Queue*)malloc(sizeof(QueType) * N);//申请N个空间。
	
	if (p->a == NULL) {//判断是否申请空间
		perror("fail");
		return;

	}
	

}

入队

链表队列

void PushBack(Tool* aa,SLType x) {
	Queue*  new =  Creat(x);
	if (aa->phead == NULL) {

		
		aa->phead = aa->ptail = new;

	}
	else
	{
		aa->ptail->next = new;
		aa->ptail = new;

	}


}

Queue* Creat(SLType x) {
	Queue* newnode = (Queue*)malloc(sizeof(SLType));
	if (newnode == NULL) {
		perror("fail");
		exit(-1);


	}
	
	newnode->next = NULL;

	newnode->val = x;

	return newnode;


}//创造新的结点

循环队列

void Pushback(Queue* p, QueType x)
{
	assert(p);
	assert(!Full(p));
	p->a[p->tail] = x;
	p->tail = (p->tail + 1) % N;//先入队再让tail++



}

打印现有队列

链表队列

void Print(Tool* aa){
	Queue* cur = aa->phead;
	while (cur!=aa->ptail->next) {
		printf("%d",cur->val);
		cur = cur->next;
	}

}//打印队列

循环队列

void Print(Queue* p) {

	int cur = p->head;
	while (cur != p->tail)
	{

		printf("%d", p->a[cur]);
		printf("\n");
		cur = (cur + 1) % N;
	}



}

返回头元素

链表队列

SLType HeadBack(Tool* aa) {
	assert(!Empty(aa));

	return aa->phead->val;
}

循环队列

Queue* HeadBack(Queue* p) {
	assert(!Empty(p));
	return p->a[p->head];

}//返回头元素

返回尾部元素

链表队列

SLType TailBack(Tool* aa){
	assert(!Empty(aa));

	return aa->ptail->val;
}

循环队列

Queue* TailBack(Queue* p) {
	
		assert(!Empty(p));
	return p->a[(p->tail - 1) % N];
		
}//返回尾部元素

销毁队列

链表队列

void Destroy(Tool* aa)
{      

	Queue* cur = aa->phead;
	while (cur)
	{
		Queue* del = cur;
		cur = cur->next;
		free(del);
		del = NULL;
	}
	aa->phead = aa->ptail = NULL;
}

循环队列

void Destroy(Queue* p){
	free(p->a);
	p->a = NULL;
	p->head = p->tail = 0;

}//销毁队列

3源代码

链表队列

SSList.h

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


typedef int SLType;
typedef struct SList
{
	struct SList* next;
	SLType val;
}Queue;

typedef struct Tool {
	Queue *ptail;
	Queue *phead;
	int sum;
}Tool;  //链表队列

//防止二级指针的方法，1.在定义

//2

void Inite(Tool* aa);//初始化
Queue* Creat(SLType x);//创造新的结点
void PushPop(Tool* aa);//出队
void Print(Tool* aa);//打印

void PushBack(Tool* aa);//入队
SLType HeadBack(Tool* aa);//返回头指针的元素
SLType TailBack(Tool* aa);//返回尾指针的元素
bool Empty(Tool* aa);//判空
void Destroy(Tool* aa);//销毁

SSList.c

#include"SSList.h"
void Inite(Tool *aa)
{
	aa->phead = NULL;
	aa->ptail = NULL;
	aa->sum = 0;

}

Queue* Creat(SLType x) {
	Queue* newnode = (Queue*)malloc(sizeof(SLType));
	if (newnode == NULL) {
		perror("fail");
		exit(-1);


	}
	
	newnode->next = NULL;

	newnode->val = x;

	return newnode;


}//创造新的结点
void PushPop(Tool* aa) {
	
	aa->phead = aa->phead->next;
	

}//出队
void Print(Tool* aa){
	Queue* cur = aa->phead;
	while (cur!=aa->ptail->next) {
		printf("%d",cur->val);
		cur = cur->next;
	}

}//打印队列

void PushBack(Tool* aa,SLType x) {
	Queue*  new =  Creat(x);
	if (aa->phead == NULL) {

		
		aa->phead = aa->ptail = new;

	}
	else
	{
		aa->ptail->next = new;
		aa->ptail = new;

	}


}
SLType HeadBack(Tool* aa) {
	assert(!Empty(aa));

	return aa->phead->val;
}
SLType TailBack(Tool* aa){
	assert(!Empty(aa));

	return aa->ptail->val;
}
bool Empty(Tool* aa) {

	return (aa->phead == NULL) && (aa->ptail == NULL);

}
void Destroy(Tool* aa)
{      

	Queue* cur = aa->phead;
	while (cur)
	{
		Queue* del = cur;
		cur = cur->next;
		free(del);
		del = NULL;
	}
	aa->phead = aa->ptail = NULL;
}

循环队列

QueueArray.h

#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include<assert.h>
#define N 5//给数组30个空间大小来存放到循环数组中
typedef int QueType;
typedef struct Queue
{
	QueType* a;
	int head;
	int tail;


}Queue;//定义结构体内部有数组，头指针和尾指针
void Inite(Queue* p);//初始化
void Pushback(Queue* p,QueType x);//入队
void PushPop(Queue* p);//出队
void Print(Queue* p);//打印现有队列
Queue* HeadBack(Queue *p);//返回头元素
Queue* TailBack(Queue* p);//返回尾部元素
bool Full(Queue* p);//判断是否为满
bool Empty(Queue* p);//判断是否为空
void Destroy(Queue* p);//销毁队列

QueueArray.c

#include"QueueArray.h"
void Inite(Queue* p)
{
	p->a = NULL;
	p->head = 0;
	p->tail = 0;
	p->a = (Queue*)malloc(sizeof(QueType) * N);
	
	if (p->a == NULL) {
		perror("fail");
		return;

	}
	

}

void Pushback(Queue* p, QueType x)
{
	assert(p);
	assert(!Full(p));
	p->a[p->tail] = x;
	p->tail = (p->tail + 1) % N;



}

void PushPop(Queue* p)
{
	p->head = (p->head + 1) % N;

}
void Print(Queue* p) {

	int cur = p->head;
	while (cur != p->tail)
	{

		printf("%d", p->a[cur]);
		printf("\n");
		cur = (cur + 1) % N;
	}



}
Queue* HeadBack(Queue* p) {
	assert(!Empty(p));
	return p->a[p->head];

}//返回头元素
Queue* TailBack(Queue* p) {
	
		assert(!Empty(p));
	return p->a[(p->tail - 1) % N];
		
}//返回尾部元素
bool Full(Queue* p) {


	return (p->tail + 1) % N == p->head;

}//判断是否为满
bool Empty(Queue* p) {

	return (p->head == 0) && (p->tail == 0);
}//判断是否为空
void Destroy(Queue* p){
	free(p->a);
	p->a = NULL;
	p->head = p->tail = 0;

}//销毁队列

4总结

我们学习了队列那我们用来干什么？
1可以用来食堂订餐的操作，订单的进入进出就会像队列一样
2在以后操作系统的学习中，队列可以用来管理任务进度与进程切换。

tyler-泰勒
关注
[数据结构笔记]二叉树初阶
niokia0v0的博客
01-28 2027
null
【数据结构初阶】顺序表
m0_60624580的博客
10-25 2277
前言前言线性表（linear list）是n个具有相同特性的数据元素的有限序列。线性表的数据在存储的时候是成一条线性相互紧邻存放的。线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串...线性表在逻辑上是线性结构，是连续的一条直线。但是在物理结构上（内存）并不一定是连续的。线性表在物理上存储时，通常以数组和链式结构的形式存储。顺序表是在物理上是线性连续的，链表是不连续的。
如何创建顺序队列
qq_43728862的博客
03-30 799
** 队列是一个线性表，但他的插入只能在队尾进行，删除只能在对头 /我们要表示一个队列，我们可以设置队列的指针我们通过对头和对尾来访问这个队列 typedef int ElemType; typedef struct SqQueue{ ElemType *base; int front; int seart; }SqQueue; 在执行入队操作时如果是队头指针并没有指向第一元素当尾指针到达...
数据结构：队列的创建与使用
Sugar_goat的博客
03-12 483
队列的结构中和单链表的结构类似，包含下一个结点的指针，同时我们还需要定义一个尾指针，来记录尾部的位置。于此之外，我们还需要创建一个新的结构体来管理整个队列：里面存储的是头部结点和尾部结点。队列中我们还要实现取出队头函数和取出队尾元素，同时我们还要计算队列中的元素。上一期中，我们学习了栈，今天我们来学习一种新的结构叫队列。以上就是关于队列的内容，希望对大家有所帮助！
队列的创建和一些用法
qq_57050396的博客
10-26 1665
在数据结构中队列是一种常见的算法，那么队列如何创建呢？ 首先我们要创建一个队列的自定义结构体 struct queue{ int data[max];//队列的数据域 int front,rear;//头尾的指针 }; 然后就是一些数列的方法 1.队列的创建 void create(queue &s){//&的作用是引用，其作用相当于指针，可以把数据的变量传递出去 s.front=-1; s.rear=-1; } 2.判断队列是否为空 i
创建一个 “队列“
weixin_52533616的博客
01-21 863
队列与栈一样，也是一种线性表，不同的是，队列可以在一端添加元素，在另一端取出元素，也就是：先进先出
创建队列流程
zhangmian_0206的博客
10-20 728
1.初始化队列：给队列属性参数赋值，再通过mq_open函数创建队列 void ExternalInit(void) { struct mq_attr qattr; //队列属性 qattr.mq_flags = 0; qattr.mq_maxmsg = EXT_MAX_QUEUE_SIZE; qattr.mq_msgsize = sizeof(ExternalEvent); extOutQueue = mq_open("external_out", O_CR...
数据结构初阶数据结构初阶
02-12
初学者在学习数据结构时，通常会遇到一系列基础概念和重要类型，这些都会在"数据结构初阶"的学习中逐步揭示。 首先，我们要理解数据结构的基本概念。数据结构是存储和组织数据的一种方式，它不仅考虑了数据的存储，...
初阶数据结构+高阶数据结构，分别用c、c++来实现.zip
10-23
本资料包"初阶数据结构+高阶数据结构，分别用c、c++来实现.zip"包含了使用C和C++语言实现的数据结构实例，旨在帮助初学者和进阶者深化对数据结构的理解。 首先，让我们从初阶数据结构开始。基础的数据结构通常包括...
队列的定义及其基本操作
热门推荐
forwardyzk的专栏
12-20 2万+
队列的定义及其基本操作 队列的定义 顺序队列及其操作 循环队列及其操作 链队列及其操作 1.队列的定义队列是限制结点插入操作固定在一端进行,而结点的删除操作固定在另一端进行的线性表. 队列犹如一个两端开口的管道.允许插入的一端称为队头,允许删除的一端称为队尾.队头和队尾各用一个”指针”指示,称为队头指针和队尾指针.不含任何结点的队列称为”空队列”.队列的特点是结点在队列中的排队次序和出队次序按进队
消息队列的建立过程
RopenYuan的专栏
09-23 7323
    消息队列提供了一种由一个进程向另一个进程发送块数据的方法。另外，每一个数据块被看作有一个类型，而接收进程可以独立接收具有不同类型的数据块。消息队列的好处在于我们几乎可以完全避免同步问题，并且可以通过发送消息屏蔽有名管道的问题。更好的是，我们可以使用某些紧急方式发送消息。坏处在于，与管道类似，在每一个数据块上有一个最大尺寸限制，同时在系统中所有消息队列上的块尺寸上也有一个最大尺寸限制。消息队列的建立过程分为四步：1.  获得获得项目相关的IPC键值，建立一个相对惟一的key值;         通过函
队列的创建以及基本操作
大芝士球的博客
02-15 1万+
队列(FIFO)是只允许在一段插入，另一端删除的线性表，遵循先进先出原则，队头删除，队尾插入。顺序队列使用用数组存储 初始条件 front =rear=0满队列：rear=m    容量m空队列:   front=rear 结构：typedef struct { int data[MAX]; int front,rear; }Queue;操作：/初始化队列 Queue InitQueue() ...
数据结构（2）队列实现（queue）
cdut2016的博客
09-07 1445
一、队列介绍 1、队列是一个有序列表，可以用数组或者链表实现。 2、遵循先入先出的原则。即：先存入队列的数据，要先取出。后存入的要后取出。 3、示意图： 数组模拟队列 1、队列本身是有序列表，若使用数组的结构来存储队列的数据，则队列数组的声明如下图, 其中 maxSize 是该队列的最大容量。 2、因为队列的输出、输入是分别从前后端来处理，因此需要两个变量 front及 rear分别记录队列前后端的下标，front 会随着数据输出而改变，而 rear则是随着数据输入而改变，如图所示: 思路： 当我们将数
一步一步建立一个队列
HeiSeDiWei的博客
12-09 1975
一步一步建立一个队列 编程注意： 1) 函数执行前先判断数据是否合理，是否为空; 2) 数据数据输入后检查输入是否输错，是否存在；类型不匹配的问题； 3) 用delete新建的对象，指针在函数运行结束指向NULL，避免内存泄露； 4) 再做插入、删除操作时，注意需要插入或删除的位置是否越界，是否在边界；
队列 - 队列的创建和基本操作
逍遥飞的博客
03-22 4790
队列 / 列队 Queue //二叉树 typedef struct Tree{ int val; Tree *left; Tree *right; //Tree(int v):val(v){} }*P_Tree; //队列 typedef P_Tree Elem; //以二叉树作为列队结点元素 struct Node{ Elem Data; ...
队列的链式建立和操作
拉风小宇的博客
11-03 6105
之前完成了堆栈的建立和操作，现在开始实现队列 队列是：具有一定操作约束的线性表 其插入和删除操作：只能在一端插入，而在另一端删除 数据插入：入队列 数据删除：出队列 先来先服务 先进先出：FIFO（First In First Out） 类型名称：队列（Queue） 数据对象集：一个有0个或者多个元素的有穷线性表 操作集，队列Q∈Queue，元素item∈ElementType
SwipeRefreshLayout和ViewPager滑动冲突的原因和正确的解决方式
最新发布
杰森丶郭达斯坦森的博客
09-30 156
重写SwipeRefreshLayout的onIntercept方法就可以很简单的解决了。以下就是重写后的SwipeRefreshLayout，直接复制到项目就可以使用了。
数据仓库初阶教程：概念、技术、应用及挑战
数据仓库（DW）是一种旨在帮助企业更好地管理和分析数据的系统，它可以帮助企业从大量数据中提取有价值的信息，从而支持企业的决策。但是，对于初学者来说，数据仓库的概念和技术可能会显得非常复杂和难以理解。幸运...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值