数据结构：队列的基本操作

最新推荐文章于 2023-09-21 13:00:00 发布
最新推荐文章于 2023-09-21 13:00:00 发布
阅读量7.9k 收藏 182
点赞数 18
分类专栏： 知识点总结
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51148715/article/details/113743163
版权

队列是一种先进先出（First in First Out）的线性表，简称FIFO。与栈不同，栈是一种后进先出（先进后出）的线性表。在队列中，允许插入的一端称为队尾，允许删除的一端称为队头。假设队列是q=（a1,a2,…,an），那么a1就是队头元素，而an是队尾元素。这样我们就可以删除时，总是从a1开始，而插入时，列在最后。这也比较符合我们通常生活中的习惯，排在第一个的优先出列，最后来的当然在队伍的最后。队列分为顺序队列和循环队列。顺序队列我们可以利用数组或者链表实现。这里，我们选择用链表实现顺序队列。

链队列

链队列的入队和出队

在这里插入图片描述

链队列的入队操作
Status EnQueue(LinkQueue *Q,QElemType e)
{
	QNode *p;
	p=(QNode *)malloc(sizeof(QNode));
	if(!p) exit(OVERFLOW);
	p->data=e;
	p->next=NULL;
	Q->rear->next=p;
	Q->rear=p;
	return OK;
}
链队列的出队操作
Status DeQueue(LinkQueue *Q,QElemType *e)
{
	QNode *p;
	if(Q->front==Q->rear)
		return ERROR;
	p=Q->front->next;
	*e=p->data;
	Q->front->next=p->next;
	if(Q->rear==p)///防止出现野指针
		Q->rear=Q->front;
	free(p);
	return OK;
}
链队列的基本操作代码(C语言版)
#include "stdio.h"
#include "stdlib.h"

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define OVERFLOW -2

typedef int QElemType;
typedef int Status;

typedef struct QNode
{
	QElemType data;
	struct QNode *next;
}QNode,*QueuePtr;
typedef struct
{
	QueuePtr front;
	QueuePtr rear;
}LinkQueue;

Status InitQueue(LinkQueue *Q)
{
	
	Q->front=(QueuePtr)malloc(sizeof(QNode));///给头尾指针分配内存，让队列中的头尾指针指向同一个内存
	Q->rear=Q->front;
	if(!Q->front) exit(OVERFLOW);
	Q->front->next=NULL;
	return OK;
}
Status EnQueue(LinkQueue *Q,QElemType e)
{
	QNode *p;
	p=(QNode *)malloc(sizeof(QNode));
	if(!p) exit(OVERFLOW);
	p->data=e;
	p->next=NULL;
	Q->rear->next=p;
	Q->rear=p;
	return OK;
}

void ShowQueueElement(LinkQueue Q)
{
	QNode *p;
	p=Q.front->next;
	while(p!=NULL)
	{
		printf("%d  ",p->data);
		p=p->next;
	}
	printf("\n");
}

int QueueLength(LinkQueue Q)
{
	int count=0;
	QNode *p;
	p=Q.front->next;
	while(p!=NULL)
	{
		count++;
		p=p->next;
	}
	return count;
}

Status DeQueue(LinkQueue *Q,QElemType *e)
{
	QNode *p;
	if(Q->front==Q->rear)
		return ERROR;
	p=Q->front->next;
	*e=p->data;
	Q->front->next=p->next;
	if(Q->rear==p)
		Q->rear=Q->front;
	free(p);
	return OK;
}

Status GetHead(LinkQueue Q,QElemType *e)
{
	QNode *p;
	p=Q.front;
	if(Q.front==Q.rear)
		return ERROR;
	*e=p->next->data;
	return OK;
}

Status ClearQueue(LinkQueue *Q)
{
	QNode *p,*q;
	p=Q->front->next;
	Q->front->next=NULL;
	while(p)
	{
		q=p->next;
		free(p);
		p=q;
	}
	Q->front=Q->rear;
	return OK;
}

Status QueueEmpty(LinkQueue *Q)
{
	if(Q->front->next==NULL)
		return TRUE;
	else
		return FALSE;
}

Status DestroyQueue(LinkQueue *Q)
{
	while(Q->front)
	{
 		Q->rear=Q->front->next;///队尾指针始终指向队头指针的下一个元素
		free(Q->front);
		Q->front=Q->rear;///调整队头指针
	}
	return OK;
}

void main()
{
	LinkQueue Q;
	int choice=1;
	if(InitQueue(&Q)==OK)
		printf("OK\n");
	else
		printf("error!\n");
	while(choice!=0)
	{
		system("cls");
		printf("1.InitQueue         2.EnQueue        3.ShowQueueElement\n");
		printf("4.DeQueue           5.GetHead        6.QueueLength    7.ClearQueue \n");
		printf("8.QueueEmpty        9.DestroyQueue     0.exit\n");
		printf("please input your choice:\n");
		scanf("%d",&choice);
		switch(choice)
		{
		case 1:
			{
				if(InitQueue(&Q)==OK)
					printf("OK\n");
				break;
			}
		case 2:
			{
				int n,i;
				QElemType num;
				printf("请输入要入队的总数：\n");
				scanf("%d",&n);
				for(i=0;i<n;i++)
				{
					scanf("%d",&num);
					if(EnQueue(&Q,num)==OK)
					printf("%d成功入队\n",num);
				}
				break;
			}
		case 3:
			{
				printf("您输入的数为：\n");
				ShowQueueElement(Q);
				break;
			}
		case 4:
			{
				QElemType e;
				int index,i,num;
				printf("请输入您想出队几个数：\n");
				scanf("%d",&num);
				index=QueueLength(Q);
				if(num>index)
					printf("越界了!\n");
				else
				{
					for(i=0;i<num;i++)
					{
						if(DeQueue(&Q,&e)==OK)
						printf("第%d次出队的元素为：%d\n",i+1,e);
					}
				}
				break;
			}
		case 5:
			{
				QElemType e;
				if(GetHead(Q,&e)==OK)
					printf("the head number is %d\n",e);
				break;
			}
		case 6:
			{
				int length;
				length=QueueLength(Q);
				printf("The queue's length is %d\n",length);
				break;
			}
		case 7:
			{
				if(ClearQueue(&Q)==OK)
					printf("成功清空队列!\n");
				else
					printf("清空队列失败!\n");
				break;
			}
		case 8:
			{
				if(QueueEmpty(&Q)==TRUE)
					printf("队列为空!\n");
				else
					printf("队列不为空!\n");
				break;
			}
		case 9:
			{
				if(DestroyQueue(&Q)==OK)
					printf("队列已销毁!\n");
				else
					printf("队列销毁失败!\n");
				break;
			}
		}
		system("pause");
	}
}

循环队列

循环队列就是将队列存储空间的最后一个位置绕到第一个位置，形成逻辑上的环状空间，供队列循环使用。在循环队列结构中，当存储空间的最后一个位置已被使用而再要进入队运算时，只需要存储空间的第一个位置空闲，便可将元素加入到第一个位置，即将存储空间的第一个位置作为队尾。循环队列可以更简单防止伪溢出的发生，但队列大小是固定的。
在循环队列中，当队列为空时，有front=rear，而当所有队列空间全占满时，也有front=rear。为了区别这两种情况，规定循环队列最多只能有MaxSize-1个队列元素，当循环队列中只剩下一个空存储单元时，队列就已经满了。因此，队列判空的条件是front=rear，而队列判满的条件是front=（rear+1)%MaxSize。

循环队列的入队和出队

在这里插入图片描述

循环队列的入队操作
Status EnQueue(SqQueue *Q,QElemType e)
{
	if((Q->rear+1)%MAXQSIZE==Q->front)
		return ERROR;
	Q->base[Q->rear]=e;
	Q->rear=(Q->rear+1)%MAXQSIZE;
	return OK;
}
循环队列的出队操作
Status DeQueue(SqQueue *Q,QElemType *e)
{
	if(Q->front==Q->rear)
		return ERROR;
	*e=Q->base[Q->front];
	Q->front=(Q->front+1)%MAXQSIZE;
	return OK;
}
循环队列的基本操作代码(C语言版)
#include "stdio.h"
#include "stdlib.h"

#define MAXQSIZE 100

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define OVERFLOW -2
typedef int QElemType;
typedef int Status;

typedef struct 
{
	QElemType *base;
	int front;
	int rear;
}SqQueue;

Status InitQueue(SqQueue *Q)
{
	Q->base=(QElemType *)malloc(MAXQSIZE*sizeof(QElemType));
	if(!Q->base) 
		exit(OVERFLOW);
	Q->front=0;
	Q->rear=0;
	return OK;
}

Status EnQueue(SqQueue *Q,QElemType e)
{
	if((Q->rear+1)%MAXQSIZE==Q->front)
		return ERROR;
	Q->base[Q->rear]=e;
	Q->rear=(Q->rear+1)%MAXQSIZE;
	return OK;
}

void ShowQueueElement(SqQueue Q)
{
	int i=0;
	for(i=0;i<(Q.rear-Q.front+MAXQSIZE)%MAXQSIZE;i++)
		printf("%d ",Q.base[i]);
		printf("\n");
}

int QueueLength(SqQueue Q)
{
	return (Q.rear-Q.front+MAXQSIZE)%MAXQSIZE;
}

Status DeQueue(SqQueue *Q,QElemType *e)
{
	if(Q->front==Q->rear)
		return ERROR;
	*e=Q->base[Q->front];
	Q->front=(Q->front+1)%MAXQSIZE;
	return OK;
}

Status IsFull(SqQueue *Q)
{
	return Q->front==(Q->rear+1)%MAXQSIZE?TRUE:FALSE;
}

Status IsEmpty(SqQueue *Q)
{
	return Q->front==Q->rear?TRUE:FALSE;
}

Status ClearQueue(SqQueue *Q)
{
	Q->front=0;
	Q->rear=0;
	return OK;
}

Status GetHead(SqQueue Q,QElemType *e)
{
	if(Q.front==Q.rear)
		return ERROR;
	*e=Q.base[Q.front];
	return OK;
}

Status DestroyQueue(SqQueue *Q)
{
	if(Q->base)
		free(Q->base);
	Q->base=NULL;
	Q->front=0;
	Q->rear=0;
	return OK;
}
void main()
{
	SqQueue Q;
	QElemType e;
	int choice=1,i;
	if(InitQueue(&Q)==OK)
		printf("OK\n");
	else
		printf("ERROR!\n");
	while(choice!=0)
	{
		system("cls");
		printf("1.InitQueue    2.EnQueue       3.ShowQueueElement \n");
		printf("4.QueueLength   5.DeQueue       6.GetHead  \n");
		printf("7.IsFull        8.IsEmpty       9.ClearQueue \n");
		printf("10.DestroyQueue     0.exit\n");
		printf("please input your choice:\n");
		scanf("%d",&choice);
		switch(choice)
		{
		case 1:
			{
				if(InitQueue(&Q)==OK)
					printf("成功创建一个队列！\n");
				break;
			}
		case 2:
			{
				int n;
				printf("请输入要入队的总数：\n");
				scanf("%d",&n);
				for(i=0;i<n;i++)
				{
					printf("请输入第%d个入队的元素：\n",i+1);
					scanf("%d",&e);
					if(EnQueue(&Q,e)==OK)
						printf("%d入队成功！\n",e);
					else
						printf("队列已满！\n");
				}
				break;
			}
		case 3:
			{
				printf("队列中的元素为：\n");
				ShowQueueElement(Q);
				break;
			}
		case 4:
			{
				int index;
				index=QueueLength(Q);
				printf("队列的长度为：%d\n",index);
				break;
			}
		case 5:
			{
				int num,index,i;
				printf("请输入您想出队几个数：\n");
				scanf("%d",&num);
				index=QueueLength(Q);
				if(num>index)
					printf("越界了!\n");
				else
				{
					for(i=0;i<num;i++)
					{
						if(DeQueue(&Q,&e)==OK)
							printf("第%d次删除的队头元素为：%d\n",i+1,e);
						else
							printf("队列为空!\n");
					}
				}
				break;
			}
		case 6:
		{
			if(GetHead(Q,&e)==OK)
				printf("队头元素为：%d\n",e);
			else
				printf("队列为空！\n");
			break;
		}
		case 7:
			{
				if(IsFull(&Q)==TRUE)
					printf("队列已满！\n");
				else
					printf("队列未满！\n");
				break;
			}
		case 8:
			{
				if(IsEmpty(&Q)==TRUE)
					printf("空队列！\n");
				else
					printf("不是空队列！\n");
				break;
			}
		case 9:
			{
				if(ClearQueue(&Q)==OK)
					printf("清空队列成功！\n");
				else
					printf("清空队列失败！\n");
				break;
			}

		case 10:
			{
				if(DestroyQueue(&Q)==OK)
					printf("销毁队列成功！\n");
				else
					printf("销毁队列失败！\n");
				break;
			}
		}
		system("pause");
	}
}
未来、梦想
关注
  • 18
    点赞
  • 踩
  • 182
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
头歌数据结构循环队列及链队列的基本操作
05-18
头歌数据结构循环队列及链队列的基本操作 第1关循环队列的基本操作 第2关链队列的基本操作 稳过 栈是一种后进先出的数据结构，而在实际问题中还经常使用一种“先进先出”的数据结构。队列就是从日常生活中的排队...
【数据结构】队列的基本操作
Jesonary的博客
04-13 2615
编写程序，实现链式、循环队列的基本操作。
数据结构之队（循环队列）的基本操作和实现
BaoITcore的博客
11-13 5993
引言：这篇文章的末尾有完整的实现代码，前面还是先进行分步实现，即我们探讨一下为什么要这样做，以及我们应该怎么样一步一步的实现循环队列。 目录 一、队列的概念 二、队的基本操作 三、对于队的操作，了解若干个规则 四、对队列的基本操作进行实现 （1）、队的初始化 （2）、判断队是否为空 （3）、求队列的长度 （4）、入队操作 （5）、出队操作 （6）、求队首元素 （7）、主函数 （8）、运行结果 （9）、完整代码 总结 一、队列的概念 我们可以把队列理解...
队列的基本操作
m0_61548909的博客
03-18 9803
目录 1.1队列的定义 1.2队列的特点 2.1队列存储的说明 2.2队列的定义 2.3队列的初始化 2.4队列的判空操作 2.5队列的入队操作 2.6队列的出队操作 2.7 队列的获取队首元素操作 2.8 队列的获取队尾元素操作 2.9 队列的计算队列元素数量操作 2.10 队列的销毁操作 3，测试代码 1.1队列的定义 队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出 FIFO(First In First...
数据结构【队列】与基本操作
hshsbabba的博客
03-22 352
只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有的特性。入队列：进行插入操作的一端称为出队列：进行删除操作的一端称为。
数据结构循环队列的基本操作
02-01
数据结构中循环队列的基本操作，分享一下，欢迎大家批评指正！
【数据结构实验】队列的应用
06-15
熟悉队列的定义，队列的特点以及队列的基本操作。能够根据实际情况选择合适的存储结构，解决实际问题。 2.实验内容： 利用循环队列模拟舞伴配对问题： 1、利用循环队列模拟舞伴配对问题。在舞会上，男、女各自排成...
Python实现基本数据结构中队列的操作方法示例
09-21
主要介绍了Python实现基本数据结构中队列的操作方法,结合实例形式演示了Python针对数据结构中队列的初始化、插入、删除、判断队列满及队列空等相关操作技巧,需要的朋友可以参考下
数据结构链队列基本操作
09-17
主要实现了数据结构链队列的基本操作，CPP完美运行无错误。
数据结构队列的基本操作（C语言）
多低调的博客
09-18 3817
队列（Queue）是另一种限定性的线性表，它只允许在表的一端插入元素，而在另一端删除元素，所以队列具有先进先出（Fist In Fist Out，缩写为FIFO)的特性。这与我们日常生活中的排队是一致的，最早进入队列的人最早离开，新来的人总是加入到队尾。在队列中，允许插入的一端叫做队尾(rear)，允许删除的一端则称为队头(front)。 本次只写了顺序队列和链队的基本操作，以及一个利用队来实现的将随机数奇偶分配输出的程序，不太严谨，尚待改进，可供参考 这次并不是写在一个源文件里的，而是分了...
【数据结构】队列的简单操作
gwPersevere的博客
05-21 913
队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出的特点。 入队列：进行插入操作的一端称为队尾，出队列：进行删除操作的一端为对头。
数据结构系列－队列的基本操作
热门推荐
lin20080410的专栏
03-19 7万+
队列(Queue)是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。允许插入的端是队尾，允许删除的端是队头。所以说队列是一个先进先出的线性表，相应的也有顺序存储和链式存储两种方式。顺序存储就是用数组实现，比如有一个ｎ个元素的队列，数组下标0的一端是队头，入队操作就是通过数组下标一个个顺序追加，不需要移动元素，但是如果删除队头元素，后面的元素就要往前移动，对应的时间复杂度就是O(n)，性能...
数据结构— — 队列的基本操作
最新发布
shsjssnn的博客
09-21 567
数据结构— — 队列的基本操作
3.2数据结构之队列知识以及运算代码（循环队列，链队）
tz1979513514的博客
04-15 702
（可以用现实生活中的排队去思考）（所以我们可以用对头和队尾来对队列进行操作）
数据结构 - 链式队列
weixin_49303682的博客
12-26 2612
1.链式队列 链式队列 ： 用链表形式实现的队列。链表结点为队列数据存储区，链表结点包括两部分数据存储 区和指针存储区。 数据存储区 ：存放真实有效数据的区域。 指针存储区 ：存放下一个链表结点的地址。 2.创建链式队列 为链式队列申请内存，即为队首指针和队尾指针申请内存。 为链式队列头结点申请内存，头结点不存放有效数据，方便队列的操作。 将队首指针和队尾指针指向头结点，即队首指针和队尾指针相等。 链式队列头结点指针域为空，即为NULL；头结点数据域可不管，亦可为零，作为链式队列有效的
数据结构——链式队列【c语言版】
clear-ninghongkang的博客
11-22 6750
队列（quque）简称队，只允许在表的一端输入，在表的另一端删除(操作受限制的线性表)， 把进行插入的一段叫做队尾（表尾），把进入删除的一端叫做队首或队头（表头）。 队列最主要的特点：先进先出，FIFO（first in first out） 队列有其实有三种：顺序队列、循环队列、链式队列 采用链式存储结构实现的队列称为链队 下面是采用单链表来实现链式队列的过程： 在链队中只允许单链表的表头进行删除操作（出队），表尾进行插入操作（入队），因此需要...
链式队列，队列篇（链式队列的出队入队操作）
qq_46104786的博客
11-06 1万+
数据结构专升本学习，队列篇（链式队列） 前言： 上一篇博主简单讲解了顺序队列和循环队列，今天讲解队列最后一篇链式队，链式队在数据结构中用到比较多，用来做一些排队的算法，还有链式队列是也是和链式栈一样采用链表的方式来表现，链式队列针对数据比较灵活的数据比较方便，因为它不像顺序队列一样需要定义最大值，链式队列只需要建立新结点，比较灵活，没有大小限制，只要内存，并且用完了就释放了，对于变动较大的数据很友好。 每日一遍，防止颓废 1.理解链式队列逻辑，认识核心代码 所谓队列的链式存储结构是用一个线性链表来表示一个
 数据结构栈和队列基本操作
06-07
栈(Stack)和队列(Queue)是两种基本的数据结构。它们都是线性结构，但它们的操作方式有所不同。 栈的基本操作有： 1. push(item)：将元素压入栈顶。 2. pop()：将栈顶元素弹出。 3. top()：返回栈顶元素，但不弹...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值