循环队列的基本操作（3种处理方式，2种实现方式）

最新推荐文章于 2023-10-23 13:10:38 发布
最新推荐文章于 2023-10-23 13:10:38 发布
阅读量576 收藏 3
点赞数
分类专栏： 数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46620129/article/details/132001233
版权
文章介绍了使用数组实现顺序队列的三种处理队列为空和队列已满情况的方法：1)牺牲一个单元格，2)增加表示元素个数的数据成员，3)增加tag数据成员。每种方法都包括了队列的初始化、判空、入队、出队和读队头元素的操作实现。
摘要由CSDN通过智能技术生成

为区分队空队满有3种处理方式：
①牺牲一个单元
②增设表示元素个数的数据成员
③增设tag数据成员

1.front->队头元素，rear->队尾元素下一位置

1.1牺牲一个单元

1.1.1定义

#define MaxSize 50
typedef struct {
	ElemType data[MaxSize];
	int front, rear;
}SqQueue;

1.1.2初始化

void InitQueue(SqQueue &Q) {
	Q.rear = Q.front = 0;
}

1.1.3判空

bool isEmpty(SqQueue Q) {
	if(Q.rear = Q.front)
		return true;
	else
		return false;
}

1.1.4 入队

bool EnQueue(SqQueue &Q, ElemType x) {
	if((Q.rear + 1) % MaxSize == Q.front)//队满报错
		return false;
	Q.data[Q.rear] = x;
	Q.rear = (Q.rear + 1) % MaxSize;
	return true;
}

1.1.5出队

bool DeQueue(SqQueue &Q, ElemType &x) {
	if(Q.rear = Q.front)//队空报错
		return false;
	x = Q.data[Q.front];
	Q.front= (Q.front+ 1) % MaxSize;
	return true;
}

1.1.6 读队头元素

bool GetHead(SqQueue &S, ElemType &x) {
	if(Q.rear = Q.front)//队空报错
		return false;
	x = Q.data[Q.front];
	return true;
}

1.2增设表示元素个数的数据成员

1.2.1定义

#define MaxSize 50
typedef struct {
	ElemType data[MaxSize];
	int front, rear;
	int size;
}SqQueue;

1.2.2初始化

void InitQueue(SqQueue &Q) {
	Q.rear = Q.front = 0;
	Q.size = 0;
}

1.2.3判空

bool isEmpty(SqQueue Q) {
	if(Q.size == 0)
		return true;
	else
		return false;
}

1.2.4 入队

bool EnQueue(SqQueue &Q, ElemType x) {
	if(Q.size == MaxSize)//队满报错
		return false;
	Q.data[Q.rear] = x;
	Q.rear = (Q.rear + 1) % MaxSize;
	return true;
}

1.2.5出队

bool DeQueue(SqQueue &Q, ElemType &x) {
	if(Q.size == 0)//队空报错
		return false;
	x = Q.data[Q.front];
	Q.front= (Q.front+ 1) % MaxSize;
	return true;
}

1.2.6 读队头元素

bool GetHead(SqQueue &S, ElemType &x) {
	if(Q.size == 0)//队空报错
		return false;
	x = Q.data[Q.front];
	return true;
}

1.3增设tag数据成员

1.3.1定义

#define MaxSize 50
typedef struct {
	ElemType data[MaxSize];
	int front, rear;
	int tag;
}SqQueue;

1.3.2初始化

void InitQueue(SqQueue &Q) {
	Q.rear = Q.front = 0;
	Q.tag = 0;
}

1.3.3判空

bool isEmpty(SqQueue Q) {
	if(Q.rear = Q.front && Q.tag == 0)
		return true;
	else
		return false;
}

1.3.4 入队

bool EnQueue(SqQueue &Q, ElemType x) {
	if(Q.rear = Q.front && Q.tag == 1)//队满报错
		return false;
	Q.data[Q.rear] = x;
	Q.rear = (Q.rear + 1) % MaxSize;
	tag = 1;
	return true;
}

1.3.5出队

bool DeQueue(SqQueue &Q, ElemType &x) {
	if(Q.rear = Q.front && Q.tag == 0)//队空报错
		return false;
	x = Q.data[Q.front];
	Q.front= (Q.front+ 1) % MaxSize;
	tag = 1;
	return true;
}

1.2.6 读队头元素

bool GetHead(SqQueue &S, ElemType &x) {
	if(Q.rear = Q.front && Q.tag == 0)//队空报错
		return false;
	x = Q.data[Q.front];
	return true;
}

2.front->队头元素，rear->队尾元素

2.1牺牲一个单元

2.1.1定义

#define MaxSize 50
typedef struct {
	ElemType data[MaxSize];
	int front, rear;
}SqQueue;

2.1.2初始化

void InitQueue(SqQueue &Q) {
	Q.front = 0;
	Q.rear = MaxSize - 1;
}

2.1.3判空

bool isEmpty(SqQueue Q) {
	if((Q.rear + 1) % MaxSize == Q.front)
		return true;
	else
		return false;
}

2.1.4 入队

bool EnQueue(SqQueue &Q, ElemType x) {
	if((Q.rear + 2) % MaxSize == Q.front)//队满报错
		return false;
	Q.rear = (Q.rear + 1) % MaxSize;
	Q.data[Q.rear] = x;
	return true;
}

2.1.5出队

bool DeQueue(SqQueue &Q, ElemType &x) {
	if((Q.rear + 1) % MaxSize == Q.front)//队空报错
		return false;
	x = Q.data[Q.front];
	Q.front= (Q.front+ 1) % MaxSize;
	return true;
}

2.1.6 读队头元素

bool GetHead(SqQueue &S, ElemType &x) {
	if((Q.rear + 1) % MaxSize == Q.front)//队空报错
		return false;
	x = Q.data[Q.front];
	return true;
}

2.2增设表示元素个数的数据成员

2.2.1定义

#define MaxSize 50
typedef struct {
	ElemType data[MaxSize];
	int front, rear;
	int size;
}SqQueue;

2.2.2初始化

void InitQueue(SqQueue &Q) {
	Q.front = 0;
	Q.rear = MaxSize - 1;
	Q.size = 0;
}

2.2.3判空

bool isEmpty(SqQueue Q) {
	if(Q.size == 0)
		return true;
	else
		return false;
}

2.2.4 入队

bool EnQueue(SqQueue &Q, ElemType x) {
	if(Q.size == MaxSize)//队满报错
		return false;
	Q.rear = (Q.rear + 1) % MaxSize;
	Q.data[Q.rear] = x;
	return true;
}

2.2.5出队

bool DeQueue(SqQueue &Q, ElemType &x) {
	if(Q.size == 0)//队空报错
		return false;
	x = Q.data[Q.front];
	Q.front= (Q.front+ 1) % MaxSize;
	return true;
}

2.2.6 读队头元素

bool GetHead(SqQueue &S, ElemType &x) {
	if(Q.size == 0)//队空报错
		return false;
	x = Q.data[Q.front];
	return true;
}

2.3增设tag数据成员

2.3.1定义

#define MaxSize 50
typedef struct {
	ElemType data[MaxSize];
	int front, rear;
	int tag;
}SqQueue;

2.3.2初始化

void InitQueue(SqQueue &Q) {
	Q.front = 0;
	Q.rear = MaxSize - 1;
	Q.tag = 0;
}

2.3.3判空

bool isEmpty(SqQueue Q) {
	if((Q.rear + 1) % MaxSize == Q.front && Q.tag == 0)
		return true;
	else
		return false;
}

2.3.4 入队

bool EnQueue(SqQueue &Q, ElemType x) {
	if((Q.rear + 1) % MaxSize == Q.front && Q.tag == 1)//队满报错
		return false;
	Q.rear = (Q.rear + 1) % MaxSize;
	Q.data[Q.rear] = x;
	tag = 1;
	return true;
}

2.3.5出队

bool DeQueue(SqQueue &Q, ElemType &x) {
	if((Q.rear + 1) % MaxSize == Q.front && Q.tag == 0)//队空报错
		return false;
	x = Q.data[Q.front];
	Q.front= (Q.front+ 1) % MaxSize;
	tag = 1;
	return true;
}

2.3.6 读队头元素

bool GetHead(SqQueue &S, ElemType &x) {
	if((Q.rear + 1) % MaxSize == Q.front && Q.tag == 0)//队空报错
		return false;
	x = Q.data[Q.front];
	return true;
}
平人的进步日常
关注
专栏目录
数据结构（C语言）：顺序循环队列的基本操作
lbcbjtlhmjq的博客
05-28 2820
① 初始化队列Q； ② 判断队列Q是否为空； ③ 入队操作。循环调用入队操作，将若干元素（不少于10个）入队； ④ 出队操作，出队一个元素，并输出该元素； ⑤ 输出队列元素个数； ⑥ 调用入队操作，依次入队4个元素； ⑦ 输出队列序列；
数据结构：图文详解 队列 | 循环队列 的各种操作（出队，入队，获取队列元素，判断队列状态）
最新发布
luming的博客
12-18 1万+
队列（Queue）是一种数据结构，是一种先进先出（First-In-First-Out，FIFO）的线性数据结构。它只允许在列表的一端进行插入操作（入队），在另一端进行删除操作（出队），即队头进行删除操作，队尾进行插入操作。队列常用的操作有入队（Enqueue）、出队（Dequeue）、获取队头元素（Front/Peek）、获取队列长度（Size/Length）等。 队列的特点是按照元素加入的先后顺序进行操作，先加入队列的元素会先被取出，后加入的元素会后被取出。 循环队列解决了普通队列的一些缺点，如空间浪费
【C++】【数据结构】循环队列的基本操作（初始化、入队、出队、取队头元素、遍历输出队列、求队列长度）顺序队列的算法实现【附全代码】
热门推荐
是小雷同学的博客
04-21 2万+
C++实现循环队列的算法+步骤（附全代码）： 使用c++完成数据结构循环队列的基本操作，包括（初始化、入队、出队、取队头元素、遍历输出队列、求队列长度等），可直接编译运行。 队列又称为 “先进先出” (FIFO)线性表。限定插入操作只能在队尾进行，而删除操作只能在队首进行。 循环队列——采用顺序存储结构来实现，用一组连续的存储单元依次存放从队首到队尾的元素，附设两个整型变量front和rear分别指向队首元素和队尾元素的位置。 循环队列的定义： #define MAXQSIZE 100 typedef
【数据结构】线性表（十）队列：循环队列及其基本操作（初始化、判空、判满、入队、出队、存取队首元素）
天地玄黄 魑魅魍魉 风花雪月 商角徵羽 暂时停更 十月重见
10-23 1862
本文介绍了循环队列及其基本操作，包括初始化队列、判断队列是否为空或已满、向队列中添加元素、移除元素以及查看队头元素等操作。
循环队列基本操作
m0_63882760的博客
05-16 2213
一.图示 二.基本操作 1.初始化 CircleQueuePtr Initialqueue() { CircleQueuePtr resultPtr=(CircleQueuePtr)malloc(sizeof(struct CircleQueue)); resultPtr->head =0; resultPtr->tail =0;\ return resultPtr; } 2.打印操作 void outputcirqueue(CircleQueuePtr paraPtr
循环队列的基本操作和实现
11-22
下面将详细介绍循环队列的基本操作和实现。 一、循环队列的结构与特性 1. 结构：循环队列通常使用数组来实现，队头和队尾的位置通过两个指针（front和rear）来标识。队头指向当前要出队的元素，队尾指向下一个要...
头歌数据结构循环队列及链队列的基本操作
05-18
在本文中，我们将深入探讨头歌数据结构中的两种基本数据结构——循环队列和链队列，以及它们在实现过程中的基本操作。首先，我们来理解这两种数据结构的概念。 循环队列是一种线性数据结构，它模拟了现实生活中的...
循环队列 C++不同策略模板实现
12-11
1. **循环队列的基本概念**：循环队列将一维数组视为一个闭合的环形空间，通过首尾相接的方式扩展了普通线性队列的功能。当队列满时，不再是在队尾插入元素而是重新从队头开始，避免了数组越界的问题。 2. **C++...
头歌 顺序表，链表，循环队列的基本操作和应用答案。
05-03
顺序表适合于数据量小且需要快速随机访问的情况，链表则适用于频繁插入和删除的操作，循环队列则在处理大量数据流或需要高效循环访问时非常有用。例如，循环队列常用于打印机队列、消息队列等系统服务中。 总的来说...
两种方法实现队列的相关操作
10-10
其次，容器实现的循环队列是一种更灵活的方法。在C++中，可以使用`std::deque`(双端队列)或`std::queue`(队列容器适配器)来实现。循环队列使用固定大小的数组，通过巧妙地管理队头和队尾的索引来模拟队列的行为。当...
关于循环队列的入队、出队、遍历的操作
Q_Demo的博客
05-29 8214
#include"stdafx.h" #include<stdio.h> #include<stdlib.h> #define MAX 100 //定义队列结构 typedef struct Queue { int *data; int rear; int front; }squeue; //初始化100个数字的队列 void Initqueue(squeue *q) { q->data=(int *)malloc(MAX*sizeof(int)); q->fr
循环队列的基本操作
absorb2601078490的博客
05-26 4293
本文介绍了有关循环队列的基本操作。 已经过调试没有很大问题。 如有错误，还请批评指正。
循环队列及链队列的基本操作
Junds0的博客
05-03 1566
第1关：循环队列的基本操作 本关任务是实现循环队列的基本操作函数，以实现判断队列是否为满、是否为空、求队列元素个数、进队和出队等功能。 #include <stdio.h> #include<stdlib.h> #include <iostream> using namespace std; // 函数结果状态代码 #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define OVER
循环队列及其基本操作
Lmznby的博客
04-22 272
包含循环队列构造、初始化、入队、出队、创建、输出队列。
《数据结构》循环队列基本操作与实现
weixin_40473591的博客
12-03 411
#include "stdio.h" #include "stdlib.h" #define TRUE 1 #define ERROR 0 #define OK 1 #define FALSE 0 #define OVERFLOW -1 typedef int QElemType; typedef int Status; #define MAXQSIZE 100 typedef struct...
[数据结构][队列]循环队列中增设tag用来区分Q.rear==Q.front是队空还是队满
furoto_的博客
07-02 1181
增设tag
循环队列的基本操作——C语言
weixin_43760048的博客
10-17 2361
/* 循环队列 队首指针 front 队尾指针 rear 1.初始化：front = 0 rear = 0 2.队列为空： front = rear 3.队满：(rear + 1) % MaxSize == front 4.入队：将新元素插入rear位置，然后rear+1 5.出队：删除front所指的元素，然后加1并返回被删除元素 6.取队首元素：返回front指向的元素值 */ #include <stdio.h> #include <stdlib.h> #define
c语言循环队列中入队出队,实现循环队列的入队,出队等基本操作.doc
weixin_39866874的博客
05-22 2761
实现循环队列的入队,出队等基本操作循环队列的基本操作??一、实验目的　　1. 理解并掌握队列的逻辑结构和顺序存储结构，了解循环队列的特点；　　2. 掌握循环队列中基本操作的相关算法；　　3. 编程实现相关算法；　　4. 学会利用循环队列解决实际问题。　　二、实验条件　　Visual C++。　　三、实验原理及相关知识　　1. 循环队列存储结构描述　　#define MAXSIZE 100 //最大...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值