队列的定义与部分习题讲解

最新推荐文章于 2024-09-25 17:17:08 发布
最新推荐文章于 2024-09-25 17:17:08 发布
阅读量1.6k 收藏 12
点赞数 1
文章标签： 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_56169816/article/details/124734824
版权

队列

一、队列的定义

​ 队列，简称队，如下图所示。它是一种运算受限的线性表，其仅允许在表的一端进行插入，而在表的另一端进行删除，通常把进行插入的一端称作队尾，进行删除的一端称作队首或对头。向队列插入新元素称作进队或入队，新元素进队后就成为新的队尾元素；从队列中删除元素称为出队或离队，元素出队后，其后继元素就成为队首元素。

在这里插入图片描述

二、队列的特点

​ 队列的主要特点是“ 先进先出 ”，即先进队的元素先出队，所以队列也称先进先出表。

三、队列的存储结构

​ 队列有两种主要的存储结构，即顺序队和链队，前者采用顺序存储结构实现队列，后者采用链式存储结构实现队列。

1.顺序队

​ 顺序队是分配一块连续的存储区域存放队列中的元素，并用两个变量分别指向队首和队尾。

1.1顺序队的结构示意图如下

在这里插入图片描述

1.2顺序队列的存储结构
#define MAXSIZE 10
typedef int ElemType;
typedef struct
{
	ElemType data[MAXSIZE];		//数据存储
	int front,rear;				//队首和队尾指针
}SqQueue,*SQ;				//声明顺序队类型

顺序队列有循环和非循环两种存储方式

1.3非循环队列的要素
	队空条件：qu.rear==qu.front
	队满条件：qu.rear=MAXSIZE-1
	元素x进队（需要移动队尾指针）：qu.rear++;qu.data[qu.rear]=x
	出队x(需移动队首指针)：qu.front++;x=qu.data[qu.front];
1.3.1循环队列的要素
队空条件：qu.rear==qu.front
队满条件：（qu.rear+1）%MAXSIZE=qu.front;
元素x进队（需要移动队尾指针）：qu.rear=(qu.rear+1)%MAXSIZE;qu.data[qu.rear]=x
出队x(需移动队首指针)：qu.front=(qu.front+1)%MAXSIZE;x=qu.data[qu.front];
2.链队
2.1链队的结构示意图如下

在这里插入图片描述

2.2链队的存储结构
typedef int ElemType;
//链队中数据节点的类型QNode声明
typedef struct qnode
{
	ElemType data;
	struct qnode* next;
}QNode;			//声明链队数据节点类型

//链队节点的类型LiQueue声明
typedef struct
{
	QNode* front;		//队头指针
	QNode* rear;		//队尾指针
}LiQueue,*LQU;			//声明链队节点类型
2.3链队的要素
队空条件：lqu->rear==NULL 或 lqu->front==NULL
队满条件：一般不考虑队满的情况
节点p进队操作：lqu-rear->next=p;lqu->rear=p;
节点p出队操作：p=lqu->front;lqu->front=p->next;x=p->data;free(p);

四、队列的基本运算

//初始化队列
void InitQueue(SqQueue& qu);

//判断是否为空
int QueueEmpty(SqQueue qu);

//进队
int EnQueue(SqQueue& qu, ElemType x);

//出队
int DeQueue(SqQueue& qu, ElemType& x);

五、顺序队的代码实现

1.代码的实现
main.cpp
#include"SqQueue.h"

void test1()
{
	ElemType x,k;
	SqQueue qu;
	InitQueue(qu);
	EnQueue(qu, 1);
	EnQueue(qu, 2);
	EnQueue(qu, 3);
}

int main()
{
	test1();
	return 0;
}
SqQueue.cpp
#include"SqQueue.h"

//初始化队列
void InitQueue(SqQueue& qu)
{
	qu.front = qu.rear = 0;
}

//判断是否为空
int QueueEmpty(SqQueue qu)
{
	return (qu.front == qu.rear);
}

//进队
int EnQueue(SqQueue& qu, ElemType x)
{
	非循环队列的定义
	//if (qu.rear = MAXSIZE - 1)
	//	return 0;
	//qu.rear++;
	//qu.data[qu.rear] = x;
	//return 1;

	if ((qu.rear + 1) % MAXSIZE == qu.front)	//队满
		return 0;
	qu.rear = (qu.rear + 1) % MAXSIZE; 
	qu.data[qu.rear] = x;		//元素x进队
	return 1;
}

//出队
int DeQueue(SqQueue& qu, ElemType& x)
{
	if (qu.rear == qu.front)		//队空
		return 0;
	qu.front = (qu.front + 1) % MAXSIZE;
	x = qu.data[qu.front];		//元素出队
	return 1;
}
SqQueue.h
#pragma once
#include<iostream>
#include<stdlib.h>
using namespace std;

#define MAXSIZE 10
typedef int ElemType;

//顺序栈的定义
/*
		栈空条件：st.top==-1
		栈满条件：st.top==MAXSIZE-1
		元素进栈操作：st.top++;st.data[st.top]=x;
		出栈操作：x=st.data[st.top];st.top--;
*/
typedef struct
{
	ElemType data[MAXSIZE];		//存放栈中元素
	int top;					//栈顶指针
}SqStack;		//声明顺序栈类型

//顺序队的定义
/*
			非循环队列的要素

	队空条件：qu.rear==qu.front
	队满条件：qu.rear=MAXSIZE-1
	元素x进队（需要移动队尾指针）：qu.rear++;qu.data[qu.rear]=x
	出队x(需移动队首指针)：qu.front++;x=qu.data[qu.front];
*/
/*
		循环队列的要素

	队空条件：qu.rear==qu.front
	队满条件：（qu.rear+1）%MAXSIZE=qu.front;
	元素x进队（需要移动队尾指针）：qu.rear=(qu.rear+1)%MAXSIZE;qu.data[qu.rear]=x
	出队x(需移动队首指针)：qu.front=(qu.front+1)%MAXSIZE;x=qu.data[qu.front];
*/
typedef struct
{
	ElemType data[MAXSIZE];		//数据存储
	int front,rear;				//队首和队尾指针
}SqQueue,*SQ;				//声明顺序队类型

//初始化队列
void InitQueue(SqQueue& qu);

//判断是否为空
int QueueEmpty(SqQueue qu);

//进队
int EnQueue(SqQueue& qu, ElemType x);

//出队
int DeQueue(SqQueue& qu, ElemType& x);
2.对顺序队列习题的讲解
2.1设计一个算法，利用队列的基本运算返回指定队列中的元素

解题思路：

​ 假设采用循环队列，队列中没有取队尾元素的基本运算，建立一个临时队列tempqu,将指定队列qu中的所有元素出队并进队到tempqu队中，这样qu队列为空，再将队列tempqu中的所有元素出队并进队到qu队中最后一个元素即为所求

代码实现

//设计一个算法，利用队列的基本运算返回指定队列中的元素
void Last(SqQueue qu, ElemType& x)
{
	SqQueue tempqu;
	InitQueue(tempqu);			//初始化队列
	while (!QueueEmpty(qu))		//qu队列不为空时
	{
		DeQueue(qu, x);			//出队元素x
		EnQueue(tempqu, x);			//将队列中的元素取出并进队到tempqu中
	}
	while (!QueueEmpty(tempqu))	//tempqu队列不为空时
	{
		DeQueue(tempqu, x);		//出队元素x
		EnQueue(qu, x);			// 将队列中的元素取出并进队到qu中
	}
}
2.2设计一个算法，利用队列和栈的基本运算将指定队列中的内容进行逆转

解题思路：

​ 假设采用循环队列，建立一个临时栈tempst，将指定队列qu中的所有元素出队并进栈到tempst栈中这样qu队列为空，在将栈tempst中的所以元素出栈并进队到qu队中，这样qu队列中的内容就发生了逆置

代码实现

//设计一个算法，利用队列和栈的基本运算将指定队列中的内容进行逆转
void Reverse(SqQueue& qu)
{
	ElemType x;
	SqStack tempst;			//定义临时栈
	InitStack(tempst);		//初始化栈tempst
	while (!QueueEmpty(qu))
	{
		DeQueue(qu, x);		//出队操作
		Push(tempst, x);	//进栈操作
	}
	while (!StackEmpty(tempst))
	{
		Pop(tempst, x);		//出栈操作
		EnQueue(qu, x);		//进队操作
	}
}

//初始化栈
void InitStack(SqStack& st)
{
	st.top = -1;
}

//判断栈是否为空
int StackEmpty(SqStack st)
{
	return (st.top == -1);
}

//数据进栈
int Push(SqStack& st, ElemType x)
{
	if (st.top == MAXSIZE - 1)
		return 0;
	st.top++;
	st.data[st.top] = x;
	return 1;
}

//数据出栈
int Pop(SqStack& st, ElemType& x)
{
	if (st.top == -1)
		return 0;
	x = st.data[st.top];
	st.top--;
}
2.3删除循环队列中第k个元素

解题思路

​ 计算队列中的个数，通过循环，在循环体内同步进行出队和进队操作，当遇到第K个元素时跳过

//删除循环队列中第k个元素
int del_k(SqQueue& qu, int k)
{
	ElemType e;
	int i;
	int count = (qu.rear - qu.front + MAXSIZE) % MAXSIZE;	//求队列中的元素个数
	if (k <= 0 || k > count)
		return 0;
	for (i = 1; i <= count; i++)
	{
		DeQueue(qu, e);		//出队，并用e保存对头的值
		if (i != k)
			EnQueue(qu, e);		//入队，e是出队是的值
	}
	return 1;
}

六、链队的代码实现

1.代码的实现
main.cpp
#include"LiQueue.h"

void test1()
{
	LQU lqu;
	ElemType x;
	InitQueue(lqu);
	EnQueue(lqu, 1);
	EnQueue(lqu, 2);
	EnQueue(lqu, 3);
}

int main()
{
	test1();
	return 0;
}
LiQueue.cpp
#include"LiQueue.h"

//初始化队列
void InitQueue(LQU& lqu)
{
	lqu = (LiQueue*)malloc(sizeof(LiQueue));
	lqu->front = NULL;
	lqu->rear = NULL;
}

//判断队空
int QueueEmpty(LQU lqu)
{
	return (lqu->rear == NULL);
}

//进队
void EnQueue(LQU& lqu, ElemType x)
{
	QNode* p;
	p= (QNode*)malloc(sizeof(QNode));
	p->data = x;
	p->next = NULL;
	if (lqu->rear == NULL)		//如果链队为空，则新节点既是头节点也是尾节点
		lqu->front = lqu->rear = p;
	else			
	{
		lqu->rear->next = p;		//将节点p链到队尾，rear指向它
		lqu->rear = p;
	}
}
LiQueue.h
#pragma once
#include<iostream>
#include<stdlib.h>
using namespace std;

typedef int ElemType;

/*
	队空条件：lqu->rear==NULL 或 lqu->front==NULL
	队满条件：一般不考虑队满的情况
	节点p进队操作：lqu-rear->next=p;lqu->rear=p;
	节点p出队操作：p=lqu->front;lqu->front=p->next;x=p->data;free(p);
*/
//链队中数据节点的类型QNode声明
typedef struct qnode
{
	ElemType data;
	struct qnode* next;
}QNode;			//声明链队数据节点类型

//链队节点的类型LiQueue声明
typedef struct
{
	QNode* front;		//队头指针
	QNode* rear;		//队尾指针
}LiQueue,*LQU;			//声明链队节点类型

//初始化队列
void InitQueue(LQU& lqu);

//判断队空
int QueueEmpty(LQU lqu);

//进队
void EnQueue(LQU& lqu, ElemType x);

总结

​ 从开始的顺序表到现在的队列，如果你也有深入学习的话，你就会发现它们有很高的相似程度，而且经过一些理解还能实现利用栈先进后出的特性可以完成队列先进先出的特性，并且它们的存储方式大都相同，顺序存储的话就是分配一块联系的存储空间，链式存储也和单链表有很大的相似，只是它们对于单链表来说有了一定的限制。

魍835
关注
微机原理与接口技术第五章习题解答.pdf
03-31
在微机原理与接口技术中，第五章主要...以上就是微机原理与接口技术第五章习题解答涉及的主要知识点，涵盖了总线的定义、分类、复用机制、信号控制以及总线周期的细节。这些内容对于理解和设计微处理器系统至关重要。
队列----定义和实现
热门推荐
LL-Studio的专栏
05-08 4万+
1、队列的定义 队列(Queue)：也是运算受限的线性表。是一种先进先出(First In First Out ，简称FIFO)的线性表。只允许在表的一端front进行插入，而在另一端rear进行删除。     队首(front) ：允许进行删除的一端称为队首。     队尾(rear) ：允许进行插入的一端称为队尾。 　　 例如：排队购物。操作系统中的作业排队。先进入队列的成员总是先离开
队列(Queue)
ChineseSoftware的博客
03-04 3万+
一、队列的概念 队列是一个先进先出的数据结构。 联想一下链表，在单链表中，只能对表尾进行插入，对表头进行结点的删除，这样强限制性的链表，就是所说的队列。也就是说，队列是限定在表的一端进行插入，表的另一端进行删除的数据结构。 如图去买票排队，每一列队伍都有一个队尾和队首，先来的先买票，后来的后买，买好的就从队首出去，新来买票的就需要从队尾继续排队。 通常，称进数据的一端为队尾，出数据的一端为队首，数据元素进队列的过程称为入队，出队列的过程称为出队。 队列是一个线性的数据结构，并且这个数据结构只允许在一端进行插
数据结构之——队列
最新发布
m0_71974552的博客
09-25 1284
队列：强大的数据结构工具
【数据结构入门】队列（Queue）详解（定义、销毁、入队、出队等）| 图解数据结构，超详细哦~
codewinter的博客
09-13 2万+
文章目录（1）前言1）队列的概念2）队列的结构（2）队列的实现（链式结构）1）队列的定义2）队列的初始化3）队列的销毁4）入队（尾插）5）出队（头删）6）获取队列元素个数7）获取队头元素8）获取队尾元素9）检查队列是否为空 数据结构系列文章： 【数据结构入门】顺序表（SeqList）详解（初始化、增、删、查、改） 【数据结构入门】无头单向非循环链表（SList）详解（定义、增、删、查、改） | 图解链表，超生动详细哦~ 【数据结构入门】带头双向循环链表（List）详解（定义、增、删、查、改） | 配有大量图
数据结构之队列
weixin_74772510的博客
08-22 2524
不会吧不会吧，不会有人不会队列吧......
【数据结构】队列详解
wangduduniubi的博客
05-19 3385
队列的结构和栈完全相反，栈只能再栈顶进再从栈顶出，遵从后进先出（LIFO）；而队列 本篇要分享的内容是队列的解析和增删查改的使用。队列的结构和栈完全相反，栈只能再栈顶进再从栈顶出，遵从后进先出（LIFO）；而队列只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，遵循的是先进先出，后进后出。入队列：进行插入操作的一端称为队尾 出队列：进行删除操作的一端称为队头
【数据结构】队列(顺序队列、循环队列、链队列）
Jacky_Feng的博客
09-15 4万+
文章目录 前言 一、队列的定义 二、队列的顺序存储结构 1.顺序队列的定义 2.循环队列定义 3.循环队列的基本操作 三、队列的链式存储结构 1.链队列的定义 2.链队列的基本操作 前言 队列也是一种线性表，其特殊性在于队列的基本操作是线性表的子集。队列按“先进先出”的规则进行操作，故称其为操作受限的线性表。 一、队列的定义 队列（queue）是只允许在一端进行插入操作，在另一端进行删除操作的线性表，简称“队”。 队列是一种先进先出（First In First Out）的
栈和队列+串+数组和广义表+树和二叉树练习题.docx
12-03
栈和队列+串+数组和广义表+树和二叉树练习题 本文档主要讲解了栈和队列、串、数组和广义表、树和二叉树等数据结构的概念和操作。通过对练习题的解答，帮助读者深入理解这些数据结构的特点和应用。 一、栈和队列 ...
分布式系统概念与设计 练习题
04-10
以上这些知识点可能会出现在“分布式系统概念与设计”的练习题中，通过解答这些题目，可以加深对分布式系统设计的理解和应用能力。在实际的学习过程中，应注重理论与实践相结合，通过编写代码或模拟系统来巩固知识。
严蔚敏教材 习题集答案 第三章 栈与队列
07-08
严蔚敏教材 习题集答案 第三章 栈与队列 本章节主要讲解了栈和队列的实现和应用，包括双向栈、括号匹配、逆串判断等多个知识点。 1. 双向栈的实现： 在第三章中，typedef struct{ Elemtype *base[2]; Elemtype *...
队列的定义
qq_57484399的博客
10-15 1096
ADT Queue{数据对象:D = { ai | ai 属于 ElemType, i=1,2,3...,n,n>=0}//ElemType为类型标识符数据关系:R = { | ai , ai+1 属于 D, i = 1,3,...,n-1}//前后顺序关系数据操作:InitQueue(&q):初始化队列 ,构造一个空队列DestroyQueue(&q):销毁队列 . 释放队列q 占用的存储空间.
【数据结构】带你深度理解队列
忆梦初心的博客
04-01 2519
与栈同理，队列也是一种限制型的数据结构，不支持随机访问。其只允许在固定的两端进行操作。因此也不存在查找，打印，修改等需要对其他位置进行操作的接口，否则会破坏队列的特性。数据结构的实现方式多种多样，为了在隐藏设计细节的情况下使用方依旧能够很方便的使用，尽管有一些操作仅仅只有一两行代码，我们还是封装成函数作为对外的接口供使用方调用。
【数据结构】队列---超详解
2201_75806908的博客
10-17 658
/定义类型//链表队列//队列特点：先进先出,队尾入数据，队头出数据}QNode;int size;}Queue;链表的结点由数据域和指针域爱两个部分构成，这就意味着我们需要对多类数据进行操作，因此定义一个结构体，正好可以满足这一需求。队列在队尾入数据，队头出数据，因此我们单独定义一个头和尾，外加一个记录队列大小的size来定义队列，以便后续实现队列的各种功能。用类型重定义关键字typedef。
LeetCode刷题|数据结构归类|队列各算法题合辑（持续补充）
weixin_45759791的博客
08-07 604
1、#232、用栈实现队列 1、题目 难度：简单 使用栈实现队列的下列操作： push(x) – 将一个元素放入队列的尾部。 pop() – 从队列首部移除元素。 peek() – 返回队列首部的元素。 empty() – 返回队列是否为空。 示例: MyQueue queue = new MyQueue(); queue.push(1); queue.push(2); queue.peek(); // 返回 1 queue.pop(); // 返回 1 queue.empty(); // 返回 fa
算法专练：队列
m0_67739923的博客
05-16 576
文章目录1.933. 最近的请求次数2.2073. 买票需要的时间3.641. 设计循环双端队列4.1670. 设计前中后队列 1.933. 最近的请求次数 原题链接         写一个 RecentCounter 类来计算特定时间范围内最近的请求。         请你实现 RecentCounter 类：   &nbsp
什么是队列？
qq_42376883的博客
12-06 1万+
第十二讲 队列 队列定义 队列是一种操作受限的线性表，只允许在表的前端（front）进行删除操作又称作出队，在表的后端进行插入操作，称为入队，符合先进先出（First in First out）的特性。在队尾插入元素叫做入队，对头删除元素叫做出队。 队列实现方式 队列实现方式总共有三种，一种是通过数组实现，一种通过链表实现，另一种通过stl中的模板 queue实现 数组实现 顺序队列 定义一个数组a[N]，并设置两个指针进行管理。一个指针为front指向队头，一个指针为rear指向队尾。当元素入队时，rea
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值