队列的基本操作（入队、出队、清空……）

最新推荐文章于 2024-02-10 22:31:15 发布
最新推荐文章于 2024-02-10 22:31:15 发布
阅读量3.5k 收藏 12
点赞数 2
分类专栏： 数据结构 C语言程序 文章标签： 链表 数据结构 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zillll/article/details/124615613
版权

队列的基本操作（入队、出队、清空……）

SqQue.h

#ifndef __SQQUE_H__
#define __SQQUE_h__
typedef int element;
typedef struct SqQue
{
    element *data;			//动态定义存储空间大小
    int max_len;			//存放最多的存储元素个数
    int now_len;			//当前存放的元素个数
    int rear;				//队尾下标，下一个入队元素的下标
    int front;				//队头下标，下一个出队元素的下标
}SqQue;

/*
	功能：初始化顺序队列
	参数：@maxl：最大长度
*/
SqQue *InitSqQue(int maxl);

/*
	功能：清空顺序栈
	参数：头指针
*/
void clearSqQue(SqQue *q);

/*
	功能：销毁顺序队列
	参数：头指针
*/
void destroySqQue(SqQue *q);

/*
	功能：判断顺序队列是否为空
	参数：头指针
	返回值：1--成功；0--失败
*/
int SqQueisempty(SqQue *q);

/*
	功能：求队列的长度
	参数：头指针
	返回值：队列的长度
*/
int SqQuelength(SqQue *q);

/*
	功能：入队
	参数：@*q：头指针；@x：入队的元素
	返回值：1--成功；0--失败
*/
int SqQuein(SqQue *q);

/*
	功能：出队
	参数：头指针;存放出队元素
	返回值：1--成功；0--失败
*/
int SqQue(SqQue *q,element *x);

/*
	功能：获取队头元素，但不出队
	参数：头指针;存放队头元素
	返回值：1--成功；0--失败
*/
int getSqQue(SqQue *q,element *x);
#endif

SqQue.c

#include<stdio.h>
#include<stdlib.h>
#include "SqQue.c"

/*
	功能：初始化顺序队列
	参数：@maxl：最大长度
*/
SqQue *InitSqQue(int maxl)
{
    SqQue *q = malloc(sizeof(*q));
    q->data = malloc(sizeof(element) * maxl);
    q->max_len = maxl;
    q->now_len = 0;
    q->rear = 0;
    q->front = 0;
    return q;
} 

/*
	功能：清空顺序队列
	参数：头指针
*/
void clearSqQue(SqQue *q)
{
    if(q == NULL)
    {
        return;
    }
    q->now_len = 0;
    q->rear = 0;
    q->front = 0;
    return;
}

/*
	功能：销毁顺序队列
	参数：头指针
*/
void destroySqQue(SqQue *q)
{
    if(q == NULL)
    {
        return;
    }
    free(q->data);
    free(q);
    return;
}

/*
	功能：判断顺序队列是否为空
	参数：头指针
	返回值：1--成功；0--失败
*/
int SqQueisempty(SqQue *q)
{
    if(q == NULL || q->now_len == 0)
    {
        return 1;
    }
    return 0;
}

/*
	功能：求队列的长度
	参数：头指针
	返回值：队列的长度
*/
int SqQuelength(SqQue *q)
{
    if(q == NULL || q->now_len == 0)
    {
        return 0;
    }
    return q->now_len;
}

/*
	功能：入队
	参数：@*q：头指针；@x：入队的元素
	返回值：1--成功；0--失败
*/
int SqQuein(SqQue *q)
{
    if(q == NULL || q->now_len == q->max_len)
    {
        return 0;
    }
    q->data[q->rear++] = x;
    q->rear = q->rear % q->max_len;
    q->now_len++;
    return 1;
}

/*
	功能：出队
	参数：头指针;存放出队元素
	返回值：1--成功；0--失败
*/
int SqQue(SqQue *q,element *x)
{
    if(q == NULL || q->now_len == 0)
    {
        return 0;
    }
    *x = q->data[q->front++];
    printf("出队元素为：%d\n",*x);
    q->front = q->front % q->max_len;
    q->now_len--;
    return1;
}

/*
	功能：获取队头元素，但不出队
	参数：头指针;存放队头元素
	返回值：1--成功；0--失败
*/
int getSqQue(SqQue *q,element *x)
{
	if(q == NULL || q->now_len == 0)
	{
		return 0;
	}
	*x = q->data[q->front];
	printf("队头元素为：%d\n",*x);
	return 1;
}

main.c

#include<stdio.h>
#include<stdlib.h>
#include "SqQue.h"

int main()
{
	int maxl,x,i;
	printf("请输入最大长度：\n");
	scanf("%d",&maxl);
	SqQue *q = InitSqQue(maxl);
	printf("请输入队列元素：\n");
	for(i = 0;i < maxl;i++)
	{
		scanf("%d",&x);
		SqQuein(q,x);
	}
	SqQueout(q,&x);
	getSqQue(q,&x);
	int m = SqQueisEmpty(q);
	printf("%d\n",m);
	clearSqQue(q);
	int n = SqQueisEmpty(q);
	printf("%d\n",n);
	
	return 0;
}

链式队列

LinkQue.h

#ifndef __LINKQUE_h__
#define __LINKQUE_h__

typedef int element;

typedef struct QNode			//数据结点
{
	element data;
	struct QNode *next;
	struct QNode *prev;
	
}QNode;

typedef struct Qlink			//头结点
{
	QNode *front;
	QNode *rear;
	element Nodenum;
}LinkQue;

/*
	功能：初始化链式队列
	返回值：头指针
*/
LinkQue *InitLinkQue(void);

/*
	功能：清空链式队列
	参数：头指针
*/
void clearLinkQue(LinkQue *q);

/*
	功能：销毁链式队列
	参数：头指针
*/
void destroyLinkQue(LinkQue *q);

/*
	功能：判断链式队列是否为空
	参数：头指针
*/
int LinkQueisempty(LinkQue *q);

/*
	功能：求链式队列的长度
	参数：头指针
	返回值：队列长度
*/
int LinkQueLenth(LinkQue *q);

/*
	功能：入队
	参数：@q：头指针；@x：入队的数据
	返回值：1--成功；0--失败
*/
int LinkQuein(LinkQue *q,element x);

/*
	功能：出队
	参数：@q：头指针；@*x：出队数据存放位置
	返回值：1--成功；0--失败
*/
int LinkQueout(LinkQue *q,element *e);

/*
	功能：获取队头元素
	参数：@q：头指针；@*x：数据存放位置
	返回值：1--成功；0--失败
*/
int GetHead(LinkQue *q, element *e);

#endif#ifndef __SQQUE_H__
#define __SQQUE_H__
typedef int element;

typedef struct SqQue
{
	element *data;			//动态定义存储空间大小
	int max_len;		//存放最多的元素个数
	int now_len;		//当前的元素个数
	int rear;			//队尾下标，下一个入队元素的下标
	int front;     		//队头下标，下一个出队元素的下标
	
}SqQue;

/*
	功能：初始化队列
	参数：@maxl：最大长度
	返回值：顺序队列的头指针
*/
SqQue *InitSqQue(int maxl);

/*
	功能：清空顺序队列
	参数：头指针
*/
void clearSqQue(SqQue *q);

/*
	功能：销毁顺序队列
	参数：头指针
*/
void destroySqQue(SqQue *q);

/*
	功能：判断顺序队列是否为空
	参数：头指针
	返回值：1--成功；0--失败
*/
int SqQueisEmpty(SqQue *q);

/*
	功能：求队列的长度
	参数：头指针
	返回值：队列的长度
*/
int SqQuelenth(SqQue *q);

/*
	功能：入队
	参数：头指针;入队的元素
	返回值：1--成功；0--失败
*/
int SqQuein(SqQue *q,element x);

/*
	功能：出队
	参数：头指针;存放出队元素
	返回值：1--成功；0--失败
*/
int SqQueout(SqQue *q,element *x);

/*
	功能：获取队头元素，但不出队
	参数：头指针;存放队头元素
	返回值：1--成功；0--失败
*/
int getSqQue(SqQue *q,element *x);



#endif

LinkQue.c

#include<stdio.h>
#include<stdlib.h>
#include "LinkQue.h"

/*
	功能：初始化链式队列
	返回值：头指针
*/
LinkQue *InitLinkQue(void)
{
	LinkQue * q = malloc(sizeof(*q));
	q->front = NULL;
	q->rear = NULL;
	q->Nodenum = 0;
	return q;
}

/*
	功能：清空链式队列
	参数：头指针
*/
void clearLinkQue(LinkQue *q)
{
	if(q == NULL)
	{
		return;
	}
	QNode *p = q->front;
	while(p)
	{
		q->front = p->next;
		if(p->next)
		{
			p->next->prev = NULL;
		}
		p->next = NULL;
		free(p);
		p = q->front;
	}
	q->rear = NULL;
	q->Nodenum = 0;
	return;
}

/*
	功能：销毁链式队列
	参数：头指针
*/
void destroyLinkQue(LinkQue *q)
{
	if(q == NULL)
	{
		return;
	}
	clearLinkQue(q);
	free(q);
}

/*
	功能：判断链式队列是否为空
	参数：头指针
*/
int LinkQueisempty(LinkQue *q)
{
	if(q == NULL || q->Nodenum == 0)
	{
		return 1;
	}
	return 0;
}

/*
	功能：求链式队列的长度
	参数：头指针
	返回值：队列长度
*/
int LinkQueLenth(LinkQue *q)
{
	if(q == NULL || q->Nodenum == 0)
	{
		return 0;
	}
	return q->Nodenum;
}

/*
	功能：入队
	参数：@q：头指针；@x：入队的数据
	返回值：1--成功；0--失败
*/
int LinkQuein(LinkQue *q,element x)
{
	if(q == NULL)
	{
		return 0;
	}
	QNode *p = malloc(sizeof(*p));
	p->data = x;
	p->next = NULL;
	p->prev = NULL;
	if(q->front == NULL)
	{
		q->front = p;
		q->rear = p;
	}
	else
	{
		q->rear->next = p;
		p->prev = q->rear;
		q->rear = p;
	}
	q->Nodenum++;
	return 1;
}

/*
	功能：出队
	参数：@q：头指针；@*x：出队数据存放位置
	返回值：1--成功；0--失败
*/
int LinkQueout(LinkQue *q,element *e)
{
	if(q == NULL || q->Nodenum == 0)
	{
		return 0;
	}
	*e = q->front->data;
	printf("出队元素：%d\n",*e);
	QNode *p = q->front;
	q->front = p->next;
	if(p->next)
	{
		p->next->prev = NULL;
		p->next = NULL;
		free(p);
	}	
	else
	{
		q->rear = NULL;
		free(p);
	}
	q->Nodenum--;
	return 1;
}

/*
	功能：获取队头元素
	参数：@q：头指针；@*x：数据存放位置
	返回值：1--成功；0--失败
*/
int GetHead(LinkQue *q, element *e)
{
	if (q == NULL || q->front == NULL)
	{
		return 0;
	}

	*e = q->front->data; 
	printf("队首元素：%d\n",*e);

	return 1;
}

main.c

#include<stdio.h>
#include<stdlib.h>
#include "LinkQue.h"

int main()
{
	element x,e;
	LinkQue *q = InitLinkQue();
	printf("请输入入队数据：\n");
	while(1)
	{
		scanf("%d",&x);
		if(x == 0)
		{
			break;
		}
		LinkQuein(q,x);
	}
	GetHead(q,&x);
	int n = LinkQueLenth(q);
	printf("长度是：%d\n",n);
	LinkQueout(q,&x);
	n = LinkQueLenth(q);
	printf("长度是：%d\n",n);
	GetHead(q,&x);
	int m = LinkQueisempty(q);
	printf("%d\n",m);
	clearLinkQue(q);
	n = LinkQueLenth(q);
	printf("长度是：%d\n",n);
	m = LinkQueisempty(q);
	printf("%d\n",m);
	return 0;
}
Joyce--
关注
  • 2
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
队列的基本操作（初始化，入队，出队，清空队，遍历队，求队长）
weixin_54724367的博客
12-29 732
队列的基本操作（初始化，入队，出队，清空队，遍历队，求队长）
C++中清空队列(queue)的方法
最新发布
xiaoxi_hahaha的博客
02-13 1570
该文章主要介绍了C++引用数据类型的基本用法以及C++ STL 队列queue清空的两种常用方法。
清空队列的方法
2301_80718054的博客
02-10 525
注意：C++中的队列queue自身不支持clear操作，但双端队列deque是支持clear操作的。
C++ 清空队列(queue)的几种方法
Blog
12-23 3947
说明：C++中的queue自身不支持clear操作，但双端队列deque是支持clear操作的。 方法一：直接用空的队列对象赋值 queue<int> q1; //process //…… q1=queue<int>(); 方法二：遍历出队列 while(!Q.empty()) { Q.pop(); } 方法三：使用swap实现 使用swap定义clear，保持ST...
C语言循环队列的实现以及相关操作（初始化、清空队列、销毁队列、判空、求长度、取队头元素、入队、出队）
weixin_50854471的博客
03-21 2120
int head;//队头下标 int rear;//队尾下标 int maxsize;//最大容量 } SqQueue;1int head;//队头下标 int rear;//队尾下标 int maxsize;//最大容量 } SqQueue;1int head;//队头下标 int rear;//队尾下标 int maxsize;//最大容量 } SqQueue;0int head;//队头下标 int rear;//队尾下标 int maxsize;
FreeRTOS学习笔记-队列
啸风
09-09 1010
基于ESP32平台进行FreeRTOS队列相关内容测试
Java定义队列结构，并实现入队、出队操作完整示例
08-25
本文主要介绍了Java定义队列结构，并实现入队、出队操作，结合完整实例形式分析了java数据结构中队列的定义、入队、出队、判断队列是否为空、打印队列元素等相关操作技巧。 一、队列结构的定义 在Java中，队列结构...
队列的入队和出队操作python
11-18
队列的操作主要包括入队（enqueue）和出队（dequeue）。在给定的代码示例中，我们看到一个简单的队列实现，下面将详细解析这些操作。 首先，创建了一个名为`Queue`的类，该类有四个方法： 1. `__init__(self)`: ...
c语言实现队列，出队入队等操作
10-11
c语言实现队列，出队入队等操作
数据结构 循环队列 入队 出队
05-01
该代码可在VC6.0平台直接编译运行，经...用数组实现了循环队列的操作，包括入队，出队，队列是否为空，队列是否为满，以及队列的遍历输出功能，各个子函数有详细的说明……希望对正在学习数据结构的同志有所帮组……
消息队列清除工具
12-22
主要用于清除消息队列中没有使用过的垃圾消息，在WINDOWS系统中。
队列 循环队列 入队 出队
05-25
队列 循环队列 入队 出队 一个完整的程序 初学者可以看看
队列的基本操作
热门推荐
麻辣清汤的博客
09-14 1万+
队列是一个插入操作和删除操作受到限制的线性表数据结构 队列的插入和删除被限制在表的两端，即插入操作只能在表的一端进行，而删除操作只能在表的另端进行，因此队列又称先进先出表 　　（1）允许删除的一端称为队头（Front）。 　　（2）允许插入的一端称为队尾（Rear）。 　　（3）当队列中没有元素时称为空队列。 　　（4）队列亦称作先进先出（First In First Out）的线性表，简称为FIFO表。 　队列的修改是依先进先出的原则进行的。新来的成员总是加入队尾（即不允许"加塞"...
队列的入队出队操作
liuxunfei15的博客
12-12 7008
#include #define MAXSIZE 30 #define OK 1 #define ERROR 0 typedef int Status; typedef int ElemType; typedef struct SqQueue { ElemType data[MAXSIZE]; int front ,rear; }Queue;   //把SqQueue
链队列（入队和出队操作）
qq_73931224的博客
04-24 570
出队操作：创建一个节点p指向队列的第一个节点，p=front->next，front->next=p->next,需要注意的是如果只有一个节点时，出队后，rear=front，两个指针都指向头结点。入队操作：创建一个新节点p存储入队元素，rear->next=p，rear=p。链队列有两个指针：front指向头结点，rear指向最后一个节点。链队列的特点：先进先出。
python 清空队列_python实现：队列
weixin_31421625的博客
03-01 2917
队列队列和栈比较类似，可以和博文：https://blog.csdn.net/weixin_42521211/article/details/88946748 参考学习。队列的一个特性是：先进先出(First In First Out, FIFO),python中，同样可以使用列表来存储队列的数据。通过创建一个队列类，便可以方便的对队列进行操作。主要有：入队(In()) 出队(Out()) 清空队...
SV语言——1.数据类型（变量类型、数组、队列、结构体、枚举类型、字符串）
weixin_44969124的博客
08-22 8907
文章目录一、变量类型——四值变量与二值变量二、固定数组——非压缩数组与压缩数组2.1.非压缩数组2.2.压缩数组三、动态数组四、队列五、联合数组六、数组方法6.1...
3.2 队列
oncruise的博客
07-25 360
定义:一种插入元素只能在一端进行, 删除元素只能在另一端进行的. 所谓队列是线性表, 是指队列的逻辑结构属于线性表, 只不过在操作上加了一些约束. 队列可以插入元素的一端叫做队尾(Rear), 可以删除元素的一端叫做队头(Front). 队列是一种的结构. First In, First Out (FIFO).图1. 元素入队和出队。
顺序队和循环队列，队列篇（顺序队和循环队列入队出队操作）
qq_46104786的博客
11-03 9927
数据结构专升本学习，队列篇（顺序队和循环队列） 前言： 之前我们把栈学完了，比较简单，今天我们学习队列里面的顺序队和循环队列，说难不难，说简单不简单，我们需要认真学习，博主会尽力把原理和逻辑讲明白，不懂的童鞋可以认真多看几遍，博主真的很想教会大家。希望大家认真看，有问题的地方可以评论提出来，希望大家，喜欢。 每日一遍，防止早恋： 1.什么是队列 队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值