数据结构之队列

已于 2024-09-07 20:25:15 修改
阅读量731 收藏 9
点赞数 10
文章标签： 数据结构
于 2024-09-07 15:40:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62681656/article/details/141994469
版权

目录

一、队列的含义

1.队列的使用

2.队列的结构  

二、顺序队列的实现

1.队列的定义

2.队列的初始化

3.清空对列

4.队列是否为空

5.获取队列的长度

6.获取头元素的值

7.入队列

8.出队列

9.遍历队列中的值

10.总代码

11.打印结果

三、链表队列的实现

1.队列的初始化

2.销毁队列

3.清理队列

4.队列是否为空

5.求队列的长度

6.获取头节点的值

7.出队列

8.入队列

9.遍历队列

10.全代码

11.打印测试

一、队列的含义

1.队列的使用

         我们在用电脑时有没有经历过，机器有时会处于疑似死机的状态，鼠标点什么似乎都没用，双击任何快捷方式都不动弹。就当你失去耐心，打算关机，突然它就像醒了一样，把你刚才点击的所有操作全部都按顺序执行了一遍。这其实是因为操作系统中的多个程序因需要通过一个通道输出，而按先后次序排队等待造成的。

         再比如像移动、联通、电信等客服电话，客服人员与客户相比总是少数，在所有的客服人员都占线的情 况下，客户会被要求等待，直到有某个客服人员空下来，才能让最先等待的客户接通电话。这里也是将 所有当前拨打客服电话的客户进行了排队处理。        

2.队列的结构  

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

        队列是一种先进先出的线性表，简称 FIFO。允许插入的一端称为队尾，允许删 除的一端称为队头。 这里从队列中的定义中，不难看出队列和栈一样也都是一种线性表，也就是说队有顺序队列和链式队两大类。        

二、顺序队列的实现

        因为顺序对列中，队列中的大小是固定的，在 tail 指针插满后，它会从0开始继续插入元素，所以说它是环形插入的，因此要考虑三种情况。在实现顺序队列之前，我们先看三张图，分别代表顺序队列的三种情况。

        第一种：head 指针 == tail 指针，此时队列中元素为空。

        第二种：head 指针 < tail 指针，此时Tail指针还没有到队列尾部。

        第三种：head 指针 > tail 指针，此时Tail指针到达队列尾部后，继续从头开始插入

1.队列的定义

        主要完成对队列的定义和一些常量的定义。

#include <iostream>
#define MAX_SIZE 20
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
typedef int Status;
typedef int ElemType;

typedef struct
{
	ElemType data[MAX_SIZE];
	int front;    // 头指针: 用来出栈
	int rear;     // 尾指针： 用来入栈
}SqQueue;
2.队列的初始化

        以为用的是双指针来代表队列，所以直接等于0就行。

// 初始化队列
Status InitQueue(SqQueue* Q)
{
	Q->front = 0;
	Q->rear = 0;
	return OK;
}
3.清空对列

        和队列的初始化一样。

// 清空队列
Status ClearQueue(SqQueue* Q)
{
	Q->front = 0;
	Q->rear = 0;
	return OK;
}
4.队列是否为空
// 队列是否为空
Status QueueEmpty(SqQueue Q)
{
	if (Q.front == Q.rear) return TRUE;
	return FALSE;
}
5.获取队列的长度
// 获取队列的长度
int QueueLength(SqQueue Q)
{
	// 需要考虑三种情况
	return (Q.rear - Q.front + MAX_SIZE) % MAX_SIZE;
}
6.获取头元素的值
// 获取头元素的值
Status GetHead(SqQueue Q, ElemType* e)
{
	if (Q.front == Q.rear) return ERROR;
	*e = Q.data[Q.front];
    return OK;
}
7.入队列
// 入队列
Status EnQueue(SqQueue* Q, ElemType e)
{
	// 判断是否满了
	if (((Q->rear + 1) % MAX_SIZE) == MAX_SIZE) return ERROR;
    Q->data[Q->rear] = e;
	Q->rear = (Q->rear + 1) % MAX_SIZE;
	return OK;
}
8.出队列
// 出队列
Status DeQueue(SqQueue* Q, ElemType* e)
{
	if (Q->front == Q->rear) return ERROR;
	*e = Q->data[Q->front];
	Q->front = (Q->front + 1) % MAX_SIZE;

	return OK;
}
9.遍历队列中的值
// 打印队列中的值
Status QueueTraverse(SqQueue Q)
{
	int i = Q.front;
	while (i != Q.rear)
	{
		if (i != Q.front) printf("->");
		printf("%d", Q.data[i]);
		i = (i + 1) % MAX_SIZE;
	}
	printf("\n");
	return OK;
}
10.总代码
#include <iostream>
#define MAX_SIZE 20
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
typedef int Status;
typedef int ElemType;

typedef struct
{
	ElemType data[MAX_SIZE];
	int front;    // 头指针: 用来出栈
	int rear;     // 尾指针： 用来入栈
}SqQueue;

// 初始化队列
Status InitQueue(SqQueue* Q)
{
	Q->front = 0;
	Q->rear = 0;
	return OK;
}

// 清空队列
Status ClearQueue(SqQueue* Q)
{
	Q->front = 0;
	Q->rear = 0;
	return OK;
}

// 队列是否为空
Status QueueEmpty(SqQueue Q)
{
	if (Q.front == Q.rear) return TRUE;
	return FALSE;
}


// 获取队列的长度
int QueueLength(SqQueue Q)
{
	// 需要考虑三种情况
	return (Q.rear - Q.front + MAX_SIZE) % MAX_SIZE;
}


// 获取头元素的值
Status GetHead(SqQueue Q, ElemType* e)
{
	if (Q.front == Q.rear) return ERROR;
	*e =  Q.data[Q.front];
	return OK;
}


// 入队列
Status EnQueue(SqQueue* Q, ElemType e)
{
	// 判断是否满了
	if (((Q->rear + 1) % MAX_SIZE) == MAX_SIZE) return ERROR;
	Q->data[Q->rear] = e;
	Q->rear = (Q->rear + 1) % MAX_SIZE;
	return OK;
}

// 出队列
Status DeQueue(SqQueue* Q, ElemType* e)
{
	if (Q->front == Q->rear) return ERROR;
	*e = Q->data[Q->front];
	Q->front = (Q->front + 1) % MAX_SIZE;
	return OK;
}

// 打印队列中的值
Status QueueTraverse(SqQueue Q)
{
	int i = Q.front;
	while (i != Q.rear)
	{
		if (i != Q.front) printf("->");
		printf("%d", Q.data[i]);
		i = (i + 1) % MAX_SIZE;
	}
	printf("\n");
	return OK;
}


int main()
{
	Status j;
	int i = 0;
	ElemType d;
	SqQueue Q;
	InitQueue(&Q);
	printf("初始化队列后，队列空否？%u(1:空 0:否)\n", QueueEmpty(Q));
	do
	{
		d = (i++) + 100;
		EnQueue(&Q, d);
	} while (i < MAX_SIZE - 1);
	printf("队列长度为: %d\n", QueueLength(Q));
	printf("现在队列中的元素为: \n");
	QueueTraverse(Q);
	while (QueueLength(Q) > 2)
	{
		DeQueue(&Q, &d);
		printf("删除的元素值为%d\n", d);
	}
	j = GetHead(Q, &d);
	if (j)
		printf("现在队头元素为: %d\n", d);
	ClearQueue(&Q);
	printf("清空队列后, 队列空否？%u(1:空 0:否)\n", QueueEmpty(Q));
	return 0;
}
11.打印结果

三、链表队列的实现

        如下图所示，Head 头节点data为 NULL，next 指向 节点值为2的节点。Tail 尾节点就等于值为 5 的节点。

1.队列的初始化
#include <iostream>
#define MAX_SIZE 20
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
typedef int Status;
typedef int ElemType;


typedef struct QNode
{
	ElemType data;
	QNode* next;
}*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 == NULL)
	{
		return ERROR;
	}

	Q->front->next = NULL;
	return OK;
}
2.销毁队列
Status DestoryQueue(LinkQueue* Q)
{
	while (Q->front)
	{
		Q->rear = Q->front->next;
		free(Q->front);
		Q->front = Q->rear;
	}
	return OK;
}
3.清理队列
Status ClearQueue(LinkQueue* Q)
{
	// 让头节点和尾节点回到初始化的状态
	QueuePtr q, p;
	Q->rear = Q->front;
	p = Q->front->next;
	Q->front->next = NULL;
	while (p) 
	{
		q = p;
		p = p->next;
		free(q);
	}
	return OK;
}
4.队列是否为空
Status QueueEmpty(LinkQueue Q)
{
	if (Q.front == Q.rear) return TRUE;
	return FALSE;
}
5.求队列的长度
int QueueLength(LinkQueue Q)
{
	int count = 0;
	QueuePtr p = Q.front;
	while (p != Q.rear && p != NULL)
	{
		p = p->next;
		count++;
	}
	return count;
}
6.获取头节点的值
Status GetHead(LinkQueue Q,ElemType* e)
{
	QueuePtr p;
	if (Q.front == Q.rear) return ERROR;
	p = Q.front->next;
	*e = p->data;
	return OK;
}
7.出队列

Status DeQueue(LinkQueue* Q,ElemType* e)
{
	if (Q->front == Q->rear) return ERROR;
	QueuePtr temp = Q->front->next;
	*e = temp->data;
	Q->front->next = temp->next;
	// 判断以下： 如果 尾节点 = temp，让头节点与尾节点相等
	if (Q->rear == temp)  Q->rear = Q->front;
	free(temp);
	return OK;
}
8.入队列
Status EnQueue(LinkQueue* Q,ElemType e)
{
	QueuePtr temp;
	temp = (QueuePtr)malloc(sizeof(QNode));
	temp->data = e;
	temp->next = NULL;
	Q->rear->next = temp;
	Q->rear = temp;
	return OK;
}
9.遍历队列
Status QueueTraverse(LinkQueue Q)
{
	QueuePtr temp = Q.front->next;
	while (temp)
	{
		if (temp != Q.front->next) printf("->");
		printf("%d", temp->data);
		temp = temp->next;
	}
	printf("\n");
	return OK;
}
10.全代码

#include <iostream>
#define MAX_SIZE 20
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
typedef int Status;
typedef int ElemType;


typedef struct QNode
{
	ElemType data;
	QNode* next;
}*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 == NULL)
	{
		return ERROR;
	}

	Q->front->next = NULL;
	return OK;
}

Status DestoryQueue(LinkQueue* Q)
{
	while (Q->front)
	{
		Q->rear = Q->front->next;
		free(Q->front);
		Q->front = Q->rear;
	}
	return OK;
}

Status ClearQueue(LinkQueue* Q)
{
	// 让头节点和尾节点回到初始化的状态
	QueuePtr q, p;
	Q->rear = Q->front;
	p = Q->front->next;
	Q->front->next = NULL;
	while (p) 
	{
		q = p;
		p = p->next;
		free(q);
	}
	return OK;
}

Status QueueEmpty(LinkQueue Q)
{
	if (Q.front == Q.rear) return TRUE;
	return FALSE;
}

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

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

Status EnQueue(LinkQueue* Q,ElemType e)
{
	QueuePtr temp;
	temp = (QueuePtr)malloc(sizeof(QNode));
	temp->data = e;
	temp->next = NULL;
	Q->rear->next = temp;
	Q->rear = temp;
	return OK;
}

Status DeQueue(LinkQueue* Q,ElemType* e)
{
	if (Q->front == Q->rear) return ERROR;
	QueuePtr temp = Q->front->next;
	*e = temp->data;
	Q->front->next = temp->next;
	// 判断以下： 如果 尾节点 = temp，让头节点与尾节点相等
	if (Q->rear == temp)  Q->rear = Q->front;
	free(temp);
	return OK;
}

Status QueueTraverse(LinkQueue Q)
{
	QueuePtr temp = Q.front->next;
	while (temp)
	{
		if (temp != Q.front->next) printf("->");
		printf("%d", temp->data);
		temp = temp->next;
	}
	printf("\n");
	return OK;
}


int main()
{
	int i;
	ElemType d;
	LinkQueue q;
	i = InitQueue(&q);
	if (i)
		printf("成功地构造了一个空队列!\n");
	printf("是否空队列？%d(1:空 0:否) ", QueueEmpty(q));
	printf("队列的长度为%d\n", QueueLength(q));
	EnQueue(&q, -5);
	EnQueue(&q, 5);
	EnQueue(&q, 10);
	printf("插入 3 个元素(-5,5,10)后,队列的长度为%d\n", QueueLength(q));
	printf("是否空队列？%d(1:空 0:否) ", QueueEmpty(q));
	printf("队列的元素依次为：");
	QueueTraverse(q);
	i = GetHead(q, &d);
	if (i == OK)
		printf("队头元素是：%d\n", d);
	DeQueue(&q, &d);
	printf("删除了队头元素%d\n", d);
	printf("队列的元素依次为：");
	QueueTraverse(q);
	i = GetHead(q, &d);
	if (i == OK)
		printf("新的队头元素是：%d\n", d);
	ClearQueue(&q);
	printf("销毁队列后,q.front=%u q.rear=%u\n", q.front, q.rear);
	return 0;
}
11.打印测试

大卫的纯爱战士
关注
C++队列
Potato_10的博客
08-20 5939
C++队列 一、基本概念： 队列是一种线性储存数据结构，数据元素遵循“先进先出”（First in First out （FIFO））的原则 添加元素在队尾（只允许添加元素）实现，删除元素在对头（只允许删除元素）实现 二、队列的操作： 判断队列是否为空 入队，通常命名为push（） 出队，通常命名为pop（） 获取队头元素，通常命名为front（） 求队列中元素个数 三、 队列的分类; 基于数组的循环队列（循环队列） 基于链表的队列（链表队列） 四、基于数组的循环队列 数组存储的缺点： 入队操作
Java数据结构之队列的简单定义与使用方法
08-29
Java数据结构之队列的简单定义与使用方法 Java数据结构之队列是计算机科学中的一种基本数据结构，具有先进先出的特点。队列是一种特殊的线性表，元素的添加和删除只能在队列的两端进行，即队头和队尾。Java中实现...
C++ Queues(队列)
weixin_33915554的博客
07-07 136
C++ Queues(队列)C++队列是一种容器适配器，它给予程序员一种先进先出(FIFO)的数据结构。1.back() 返回一个引用，指向最后一个元素2.empty() 如果队列空则返回真3.front() 返回第一个元素4.pop() 删除第一个元素5.push() 在末尾加入一个元素6.size() 返回队列中元素的个数队列可以用线性表(list)或双向队列(deque)来实现(注意vect...
C++ queue(STL queue，队列)用法详解
最新发布
szm111213的博客
08-21 1631
图 1 queue容器底层容器必须提供这些操作：front()、back()、push_back()、pop_front()、empty() 和 size()。
c++队列
qq_19457459的博客
05-13 1166
队列 队列其实就是简单的链表，只是添加了队头和队尾指针。限制了添加和删除只能从队尾和队头操作。 代码实现 #include <iostream> using namespace std; // 结点 typedef struct QNode { int data; struct QNode *next; }QNode, *QueuePtr; // 链表结构 typedef struct { QueuePtr front, rear; // 队头，队尾指针 }LinkQueue;
数据结构 &栈和队列（二）
csdn_edition的博客
11-11 144
队列是一种先进先出的线性表，只允许在表的一端进行插入另一端进行删除。允许插入的一端称为队尾，允许删除的一端称为队头。 同样的我们先来设计队列的结构： typedef int ElemType;//类型重定义 #define MAXSIZE 10//队列的最大容量为10 typedef struct Queue { ElemType *base; int head;//队头 int rear;//队尾 }Que,*pQue; 和栈一样，对一个空队列（不存在的队列）进行操作是毫无意义的，因此在进行所有操
数据结构-使用javascript讲解数据结构之队列.zip
02-12
在这个专题中，我们重点关注的是使用JavaScript语言来讲解的数据结构之一：队列。队列是一种线性数据结构，其操作特性类似于现实生活中的排队等候，遵循“先进先出”（FIFO）的原则。 在JavaScript中，队列可以通过...
数据结构之队列的java实现
12-22
队列也是一种数据结构，类似于栈，只是与栈相反，在队列中先插入的数据也先被移除，即先进先出(FIFO，First In First Out)。队列可以理解成排队，比如，食堂窗口排的队，越在前面的，越早得到服务而先离开。在银行...
数据结构之队列.rar
04-07
这个压缩包文件“数据结构之队列.rar”显然是关于队列数据结构的深入探讨，特别是结合了C++编程语言的应用。 队列的基本概念： 队列是一种线性数据结构，其一端允许元素的插入（称为后端或尾部），另一端允许元素的...
基于最大堆实现的优先队列。
Hello什么来着？
04-21 373
一、概念 普通的队列是一种先进先出的数据结构，元素在队列尾追加，而从队列头删除。在优先队列中，元素被赋予优先级。当访问元素时，具有最高优先级的元素最先删除。优先队列具有最高级先出 （first in, largest out）的行为特征。通常采用堆数据结构来实现。 二、代码实现 import 队列.Queue; public class PriorityQueue<E extends ...
【C++】队列
taoxing
07-09 295
文章目录一.基本介绍二.代码实现三.结果展示 一.基本介绍 队列，一种先进先出（FIFO，First-In-First-Out）的线性表，通常用链表或者数组来实现。队列只允许在后端（rear）插入，在前端（front）取出删除。 与堆栈唯一的区别就是只允许新数据在尾部添加。 我们用数组来实现队列，需要以下4个基本变量： 变量名 含义 arr 存储数据的数组 maxSize 队列的最大容量 front 队列头，随着数据输出而改变 rear 队列尾，随着数据输入而改变 基
C++之队列和优先队列
Lavi的专栏
08-01 5193
转载自：http://www.cppblog.com/wanghaiguang/archive/2012/06/05/177644.html http://www.cnblogs.com/heqinghui/archive/2013/07/30/3225407.html http://blog.csdn.net/sun_168/article/details/7680911 C++
C++：队列
qq_28414091的博客
03-03 1122
【代码】C++链式队列的实现。
Java基础：深入理解数据结构之队列
"Java基础数据结构-队列的理论与实现" 在计算机科学中，数据结构是组织和存储数据的方式，以便高效地访问和修改。队列作为一种基础数据结构，其特性在于遵循“先进先出”（FIFO, First In First Out）原则。简单来...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

大卫的纯爱战士

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

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

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

打赏作者

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

抵扣说明：

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

余额充值