C语言队列实现

最新推荐文章于 2024-09-29 11:52:07 发布
最新推荐文章于 2024-09-29 11:52:07 发布
阅读量355 收藏 2
点赞数
分类专栏： C语言 文章标签： c语言 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44453694/article/details/134176810
版权

1.知识百科

  队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。
  队尾（rear）：只能从队尾添加元素，一般焦作enQueue，入队
  队头（front）：只能从队头移除元素，一般焦作deQueue，出队
  先进先出的原则、First In Fist Out，FIFO（跟栈是反的，栈是后进先出）
  在生活中队列案例也是随处可见。例如火车站排队买票，银行排队办理业务。
在这里插入图片描述

2.C语言队列实现

  队列可以采用数组或者链表方式实现，数组方式实现存在局限性，数据类型单一，空间大小一开始就需要固定，链表方式实现则比较灵活。

2.1 数组方式实现队列

#include <stdio.h>
#include <string.h>
#include <pthread.h>
#include <unistd.h>
#define QUEUE_COUNT 50 //队列缓冲区大小
//互斥锁
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

//队列结构体信息
struct Queue_Info{
	int buffer[QUEUE_COUNT];
	int queue_end;//下标
};
struct Queue_Info QueueDat;//队列结构体信息
//判断队列是否满
int Queue_JudgeFull()
{
	if(QueueDat.queue_end>=(QUEUE_COUNT-1))return 1;//队列满
	return 0;//队列未满
}
//判断队列是否为空
int Queue_JudgeNull()
{
	if(QueueDat.queue_end==0)return 1;//队列空
	return 0;//队列有数据
}
//初始化队列
void Queud_Init(void)
{
	memset(&QueueDat,0,sizeof(QueueDat));
}
//入队
int Queud_InPut(int dat)
{
	if(Queue_JudgeFull())return 1;//队列满
	QueueDat.buffer[QueueDat.queue_end++]=dat;
	return 0;
}
//出队
int Queue_OutPut(int *dat)
{
	if(Queue_JudgeNull())return 1;//队列空
	*dat=QueueDat.buffer[0];//从队列头取数据
	//将数组中的数据往前移动
	int i;
	QueueDat.queue_end--;
	for(i=0;i<QueueDat.queue_end;i++)
	{
		QueueDat.buffer[i]=QueueDat.buffer[i+1];
	}
	QueueDat.buffer[i]=0;
	return  0;
}
void *pth_work(void *arg)
{
	int temp;
	while(1)
	{
		//子线程中出队操作
		pthread_mutex_lock(&mutex);//上锁
		if(Queue_OutPut(&temp))
		{
			printf("【子线程1】队列空\n");
		}
		else
		{
			printf("【子线程1】出队成功temp=%d\n",temp);
		}
		pthread_mutex_unlock(&mutex);//解锁
		usleep(300000);
	}	
}
void *pth_work2(void *arg)
{
	int temp;
	while(1)
	{
		//子线程中出队操作
		pthread_mutex_lock(&mutex);//上锁
		if(Queue_OutPut(&temp))
		{
			printf("【子线程2】队列空\n");
		}
		else
		{
			printf("【子线程2】出队成功temp=%d\n",temp);
		}
		pthread_mutex_unlock(&mutex);//解锁
		usleep(200000);
	}	
}
int main()
{
	//初始化队列
	Queud_Init();
	pthread_t pthid;
	//创建线程
	pthread_create(&pthid,NULL,pth_work,NULL);
	pthread_detach(pthid);//设置为分离属性
	pthread_create(&pthid,NULL,pth_work2,NULL);
	pthread_detach(pthid);//设置为分离属性
	int cnt=0;
	while(1)
	{
		//主线程中进行入队
		pthread_mutex_lock(&mutex);//上锁
		cnt++;
		if(Queud_InPut(cnt))
		{
			printf("队列满\n");
		}
		else
		{
			printf("【主线程】入队成功\n");
		}
		pthread_mutex_unlock(&mutex);//解锁
		usleep(200000);
	}
}

在这里插入图片描述

2.2 环形队列

  环形队列的一个有用特性是：当一个数据元素被用掉后，其余数据元素不需要移动其存储位置。相反，一个非环形队列（例如一个普通的队列）在用掉一个数据元素后，其余数据元素需要向前搬移。

在这里插入图片描述

#include <stdio.h>
#include <string.h>
#include <pthread.h>
#include <unistd.h>
#define QUEUE_COUNT 50 //队列缓冲区大小
//互斥锁
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

//队列结构体信息
struct Queue_Info{
	int buffer[QUEUE_COUNT];//缓冲区
	int queue_count;//成员个数
	int queue_in;//存入数据下标
	int queue_out;//取出数据下标
};
struct Queue_Info QueueDat;//队列结构体信息
//判断队列是否满
int Queue_JudgeFull()
{
	if(QueueDat.queue_count>=QUEUE_COUNT)return 1;//队列满
	return 0;//队列未满
}
//判断队列是否为空
int Queue_JudgeNull()
{
	if(QueueDat.queue_count==0)return 1;//队列空
	return 0;//队列有数据
}
//初始化队列
void Queud_Init(void)
{
	memset(&QueueDat,0,sizeof(QueueDat));
}
//入队
int Queud_InPut(int dat)
{
	if(Queue_JudgeFull())return 1;//队列满
	QueueDat.buffer[QueueDat.queue_in]=dat;
	QueueDat.queue_in=(QueueDat.queue_in+1)%QUEUE_COUNT;//保证下标不会超过缓冲区
	QueueDat.queue_count++;//成员个数++
	return 0;
}
//出队
int Queue_OutPut(int *dat)
{
	if(Queue_JudgeNull())return 1;//队列空
	*dat=QueueDat.buffer[QueueDat.queue_out];//从队列中取数据
	QueueDat.queue_out=(QueueDat.queue_out+1)%QUEUE_COUNT;//保证下标不会超过缓冲区
	QueueDat.queue_count--;//成员个数-1
	return  0;
}
void *pth_work(void *arg)
{
	int temp;
	while(1)
	{
		//子线程中出队操作
		pthread_mutex_lock(&mutex);//上锁
		if(Queue_OutPut(&temp))
		{
			printf("【子线程1】队列空\n");
		}
		else
		{
			printf("【子线程1】出队成功temp=%d\n",temp);
		}
		pthread_mutex_unlock(&mutex);//解锁
		usleep(80000);
	}	
}
void *pth_work2(void *arg)
{
	int temp;
	while(1)
	{
		//子线程中出队操作
		pthread_mutex_lock(&mutex);//上锁
		if(Queue_OutPut(&temp))
		{
			printf("【子线程2】队列空\n");
		}
		else
		{
			printf("【子线程2】出队成功temp=%d\n",temp);
		}
		pthread_mutex_unlock(&mutex);//解锁
		usleep(200000);
	}	
}
int main()
{
	//初始化队列
	Queud_Init();
	pthread_t pthid;
	//创建线程
	pthread_create(&pthid,NULL,pth_work,NULL);
	pthread_detach(pthid);//设置为分离属性
	pthread_create(&pthid,NULL,pth_work2,NULL);
	pthread_detach(pthid);//设置为分离属性
	int cnt=0;
	while(1)
	{
		//主线程中进行入队
		pthread_mutex_lock(&mutex);//上锁
		cnt++;
		if(Queud_InPut(cnt))
		{
			printf("队列满\n");
		}
		else
		{
			printf("【主线程】入队成功\n");
		}
		pthread_mutex_unlock(&mutex);//解锁
		usleep(50000);
	}
}

在这里插入图片描述

2.3 链表方式实现队列

#include <stdio.h>
#include <string.h>
#include <pthread.h>
#include <unistd.h>
#include <stdlib.h>
#include <signal.h>
//互斥锁
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

//结构体信息
struct Queue_Info{
	int data;
	struct Queue_Info *next;
};
struct Queue_Info *Queue_head;//队列结构体
//初始化队列
struct Queue_Info *Queud_Init(struct Queue_Info *Queue_head,int dat)
{
	if(Queue_head==NULL)
	{
		Queue_head=malloc(sizeof(struct Queue_Info));
		Queue_head->next=NULL;
	}
	Queue_head->data=dat;//添加数据内容
	return Queue_head;
}
//销毁队列
struct Queue_Info *Queud_Destroy(struct Queue_Info *Queue_head)
{
	if(Queue_head==NULL)return Queue_head;
	struct Queue_Info *phead=Queue_head;
	struct Queue_Info *temp=phead;
	int count=0;
	while(phead!=NULL)
	{
		temp=phead;
		phead=phead->next;
		free(temp);
		count++;
	}
	printf("销毁的成员个数:%d\n",count);
	return phead;
}
//获取队列中元素个数
int Queud_GetCount(struct Queue_Info *Queue_head)
{
	struct Queue_Info *phead=Queue_head;
	int count=0;
	while(phead!=NULL)
	{
		phead=phead->next;
		count++;
	}
	return count;
}

//入队(从链表尾添加节点)
struct Queue_Info *Queud_InPut(struct Queue_Info *Queue_head,int dat)
{
	struct Queue_Info *phead=Queue_head;
	if(phead==NULL)
	{
		Queue_head=Queud_Init(Queue_head,dat);
		return Queue_head;
	}
	while(phead->next!=NULL)
	{
		phead=phead->next;
	}
	struct Queue_Info *new=malloc(sizeof(struct Queue_Info));//创建节点
	new->next=NULL;
	phead->next=new;
	new->data=dat;//添加节点内容
	return Queue_head;
}
//出队(从链表头删除节点)
struct Queue_Info *Queue_OutPut(struct Queue_Info *Queue_head,int *dat)
{
	struct Queue_Info *phead=Queue_head;
	if(phead==NULL)return (void *)-1;//队列NULL
	//从队列中取数据
	*dat=phead->data;//取数据
	Queue_head=phead->next;
	free(phead);//释放节点
	return  Queue_head;
}
void *pth_work(void *arg)
{
	int temp;
	while(1)
	{
		//子线程中出队操作
		pthread_mutex_lock(&mutex);//上锁
		Queue_head=Queue_OutPut(Queue_head,&temp);
		if(Queue_head==(void *)-1)
		{
			Queue_head=NULL;
			printf("【子线程1】队列空\n");
		}
		else
		{
			printf("【子线程1】出队成功temp=%d\n",temp);
		}
		pthread_mutex_unlock(&mutex);//解锁
		usleep(80000);
	}	
}
void *pth_work2(void *arg)
{
	int temp;
	while(1)
	{
		//子线程中出队操作
		pthread_mutex_lock(&mutex);//上锁
		Queue_head=Queue_OutPut(Queue_head,&temp);
		if(Queue_head==(void *)-1)
		{
			Queue_head=NULL;
			printf("【子线程2】队列空\n");
		}
		else
		{
			printf("【子线程2】出队成功temp=%d\n",temp);
		}
		pthread_mutex_unlock(&mutex);//解锁
		usleep(200000);
	}	
}
void sig_func(int sig)
{
	if(sig==2)//销毁队列
	{
		pthread_mutex_lock(&mutex);//上锁
		printf("成员个数:%d\n",Queud_GetCount(Queue_head));
		Queue_head=Queud_Destroy(Queue_head);
		pthread_mutex_unlock(&mutex);//解锁
	}
}
int main()
{
	signal(SIGINT,sig_func);//捕获CTRL+C信号
	//初始化队列
	int cnt=0;
	Queue_head=Queud_Init(Queue_head,cnt);
	pthread_t pthid;
	//创建线程
	pthread_create(&pthid,NULL,pth_work,NULL);
	pthread_detach(pthid);//设置为分离属性
	pthread_create(&pthid,NULL,pth_work2,NULL);
	pthread_detach(pthid);//设置为分离属性
	
	while(1)
	{
		//主线程中进行入队
		pthread_mutex_lock(&mutex);//上锁
		cnt++;
		Queue_head=Queud_InPut(Queue_head,cnt);
		printf("【主线程】入队成功,count=%d\n",Queud_GetCount(Queue_head));
		pthread_mutex_unlock(&mutex);//解锁
		usleep(50000);
	}
}

在这里插入图片描述

IT_阿水
关注
专栏目录
队列的实现(C语言)
weixin_75245339的博客
05-17 581
队列的实现(C语言)
c语言实现队列
m0_61438674的博客
10-05 5429
c语言实现队列
C语言实现循环队列缓冲区模块（附代码）
weixin_43854957的博客
05-19 938
FIFO 是First-In First-Out的缩写，它是一个具有先入先出特点的缓冲区。 可以理解成一个大的水池，水对应数据，注水速度对应数据输入的频率，放水速度对应数据处理的速度，当注水速度和放水速度相同时，我们不需要使用水池来缓冲，但是当注水速度大于放水速度，或者注水速度突然变大时（突发），为了保证水池不溢出（数据不丢失），就需要水池（缓冲区）来处理这种突发情况，并设置合理大小的水池空间（FIFO的深度）。
C语言实现队列
最新发布
2401_86557724的博客
09-29 898
本章使用C语言实现了数据结构中的队列，队列的结构也不是很难，实现难度也不是很大，但是队列的作用却很大，值得我们去亲自实现它。
队列的实现（C语言版）
C12345bbbbbb的博客
11-06 357
我们约定front指向队头的前一个元素，rear指向队尾元素。随着元素的添加，数组会存满。但是当我们取出元素之后，低端还有空位置。这种现象叫做假溢出。我们解决的办法就是当存满之后，继续往下标最小的位置延续。这样的顺序队列，我们称为循环队列。只允许一端插入，在另一端删除操作的线性表。允许插入操作的一端称为队尾，允许删除操作的一端称为队头。满足先进先出的特性。队列的顺序存储结构也称为顺序队列。二.队列的顺序存储结构。
队列（C语言实现）
m0_59311392的博客
09-18 3719
1.1 定义：队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出 FIFO(First In First Out)入队列：进行插入操作的一端称为队尾出队列：进行删除操作的一端称为队头int front;int rear;}QueNode;int size;}Queue双端队列是指允许两端都可以进行入队和出队操作的队列。其元素的逻辑结构仍是线性结构。将队列的两端称为前端和后端，两端都可以入队和出队。
队列的实现（c语言数据结构）
芊樱烛渊的博客
05-15 919
一、需要实现的功能 以下是我们栈需要实现的功能 #pragma once #include <stdio.h> #include <stdlib.h> #include <stdbool.h> #include <assert.h> typedef int QDataType; //定义我们队列的结点 typedef struct QueueNode { QDataType data; struct QueueNode* next;
队列——（c语言实现）
2302_77041624的博客
05-12 2541
队列，是一种先进先出（first in first out 简称FIFO）的数据结构，是只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，在队列中，进行插入的一端称为队尾，进行删除的一端称为队头。
c语言队列实现（不强制数据类型，包含三种实现）
07-26
c语言队列实现（不强制数据类型，包含三种实现）
C语言队列的实现及头文件
12-28
在自身写C实现二叉树时所写的队列的实现代码，内附代码和头文件，在头文件中修改 QueueType 的define还有 InputQueue 函数就可以适配其余功能例如其他结构体。 初始QueueTpye 为int型
C语言版实现链队列
12-25
本文实例为大家分享了C语言实现链队列的具体代码，供大家参考，具体内容如下 源文件部分： 指针没学好的同学很难看懂^_^，有点乱，希望对大家有点帮助。 #include #include #include #include typedef int ...
C语言队列实现：数组内存分配方式解析
资源摘要信息:"C语言队列的实现概述" C语言是一种广泛使用的编程语言，它的高效性和灵活性使其在系统编程领域非常受欢迎。队列是一种广泛应用于各种算法和数据结构中的先进先出（FIFO）数据结构。在C语言中实现队列...
队列的两种C++实现
扬风踏浪
07-28 156
像栈一样，队列（queue）也是表。然而，使用队列时插入在一端进行而删除则在另一端进行，也就是先进先出（FIFO）。队列的基本操作是EnQueue（入队），它是在表的末端（叫做队尾（rear））插入一个元素；还有DeQueue（出队），它是删除（或返回）在表的开头（叫做队头（fr
队列的实现（C语言）
热门推荐
peng_fp的博客
03-28 2万+
队列实现demo
C队列实现
the_best_one1的博客
02-02 403
队列 队列是先进先出的结构 队列实现 queue.h #include <stdlib.h> #define QUEUE_TYPE int void create_queue(size_t size); void destroy_queue(void); void insert( QUEUE_TYPE value ); void delete( void ); QUEUE_TYPE first( void ); int is_empty(void); int is_fu
C语言队列的实现
我的博客
04-16 1629
系列文章目录 文章目录系列文章目录队列一、队列是什么？二、队列的实现1.定义数据类型2.队列的各种接口3.初始化队列4.销毁队列5.入队6.出队7.队列是否为空8.求队列长度9.获取队头数据10.获取队尾数据总结 队列 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、队列是什么？ 队列是一种特殊的线性表，特点是FIFO，适合用链式结构实
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

IT_阿水

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

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

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

打赏作者

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

抵扣说明：

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

余额充值