数据结构之顺序循环队列

最新推荐文章于 2024-05-12 06:30:00 发布
最新推荐文章于 2024-05-12 06:30:00 发布
阅读量2.9k 收藏 13
点赞数 6
分类专栏： # 队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41587740/article/details/104145480
版权

顺序循环队列

思维导图：

在这里插入图片描述

队列的定义：

队列依旧是一种特殊的线性表。但是它只允许在一端进行插入，在另一端进行删除操作。
在这里插入图片描述

队列的特点

FIFO：first in first out

队列的基本操作：

 初始化队列：InitQueue(&Q)
 销毁队列：DestoryQueue(&L)
 入队：EnQueue(&Q,x)
 出队：DeQueue(&Q,&x)
 读队头元素：GetHead(s,&x)
 判空栈：QueueEmpty(S)

顺序循环队列基本操作的实现：

情况一：rear和front指向同一位置时

在这里插入图片描述

队列定义：

1.用牺牲一个节点为代价判断空和满

typedef struct{
	int data[MaxSize];
	int front,rear;
}SqQueue;

2.用size标记判断空和满

typedef struct{
	int data[MaxSize];
	int front,rear;
	int size;		//size为0则空，size为MaxSize则满
}SqQueue;

3.用tag标记判断空和满

typedef struct{
	int data[MaxSize];
	int front,rear;
	int tag;		//入队为1，出队为0
}SqQueue;

队列初始化：

1.用牺牲一个节点为代价判断空和满

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

2.用size标记判断空和满

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

3.用tag标记判断空和满

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

入队：

1.用牺牲一个节点为代价判断空和满
在这里插入图片描述ps: 计算队列元素个数：
　　(rear+MaxSize-front) % MaxSize
eg:(2+10-3) % 10 = 9(上图)

bool EnQueue(SqQueue &Q,int x){
	if((Q.rear+1) % MaxSize == Q.front)
		return false;
	Q.data[Q.rear] = x;
	Q.rear = (Q.rear + 1) % MaxSize;
	return true; 
}

2.用size标记判断空和满
在这里插入图片描述

bool EnQueue(SqQueue &Q,int x){
	if(Q.size == MaxSize)
		return false;
	Q.data[Q.rear] = x;
	Q.rear = (Q.rear + 1) % MaxSize;
	size ++;
	return true; 
}

3.用tag标记判断空和满
在这里插入图片描述

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

出队：

1.用牺牲一个节点为代价判断空和满
在这里插入图片描述

bool DeQueue(SqQueue &Q,int &x){
	if(Q.rear == Q.front)
		return false;
	x = Q.data[Q.front];
	Q.front = (Q.front + 1) & MaxSize;
	return true;
}

2.用size标记判断空和满
在这里插入图片描述

bool DeQueue(SqQueue &Q,int &x){
	if(Q.size == 0)
		return false;
	x = Q.data[Q.front];
	Q.front = (Q.front + 1) % MaxSize;
	size --;
	return true;
}

3.用tag标记判断空和满
在这里插入图片描述

//每次删除操作成功时都令tag=0，只有删除操作才可能导致队空
//每次插入操作成功时都令tag=1，只有插入操作才可能导致队满
bool EnQueue(SqQueue &Q,int x){
	if(Q.front == Q.rear && tag == 0)
		return false;
	x = Q.data[Q.rear];
	Q.front= (Q.front+ 1) % MaxSize;
	tag = 0;
	return true; 
}

队列判空：

1.用牺牲一个节点为代价判断空和满

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

2.用size标记判断空和满

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

3.用tag标记判断空和满

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

返回队头元素：

1.用牺牲一个节点为代价判断空和满

bool GetHead(SqQueue &Q,int &x){
	if(Q.rear == Q.front)
		return false;
	x = Q.data[Q.front];
	return true;
}

2.用size标记判断空和满

bool GetHead(SqQueue &Q,int &x){
	if(Q.size == 0)
		return false;
	x = Q.data[Q.front];
	return true;
}

3.用tag标记判断空和满

bool GetHead(SqQueue &Q,int &x){
	if(Q.front == Q.rear && tag == 0)
		return false;
	x = Q.data[Q.front];
	return true;
}

情况二：rear在front后面

在这里插入图片描述

队列定义：

1.用牺牲一个节点为代价判断空和满

typedef struct{
	int data[MaxSize];
	int front,rear;
}SqQueue;

2.用size标记判断空和满

typedef struct{
	int data[MaxSize];
	int front,rear;
	int size;
}SqQueue;

3.用tag标记判断空和满

typedef struct{
	int data[MaxSize];
	int front,rear;
	int tag;
}SqQueue;

队列初始化：

1.用牺牲一个节点为代价判断空和满

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

2.用size标记判断空和满

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

3.用tag标记判断空和满

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

入队：

1.用牺牲一个节点为代价判断空和满
在这里插入图片描述

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

2.用size标记判断空和满

bool EnQueue(SqQueue &Q,int x){
	if(Q.size == MaxSize)
		return false;
	Q.rear = (Q.rear + 1) % MaxSize;
	Q.data[Q.rear] = x;
	size ++;
	return true; 
}

3.用tag标记判断空和满

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

出队：

1.用牺牲一个节点为代价判断空和满
在这里插入图片描述

bool DeQueue(SqQueue &Q,int &x){
	if((Q.rear+1) % MaxSize == Q.front)
		return false;
	Q.front = (Q.front + 1) & MaxSize;
	x = Q.data[Q.front];
	return true;
}

2.用size标记判断空和满

bool DeQueue(SqQueue &Q,int &x){
	if(Q.size == 0)
		return false;
	Q.front = (Q.front + 1) % MaxSize;
	x = Q.data[Q.front];
	size --;
	return true;
}

3.用tag标记判断空和满

//每次删除操作成功时都令tag=0，只有删除操作才可能导致队空
//每次插入操作成功时都令tag=1，只有插入操作才可能导致队满
bool EnQueue(SqQueue &Q,int x){
	if((Q.rear+1) % MaxSize == Q.front && tag == 0)
		return false;
	Q.front= (Q.front+ 1) % MaxSize;
	x = Q.data[Q.rear];
	tag = 0;
	return true; 
}

队列判空：

1.用牺牲一个节点为代价判断空和满

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

2.用size标记判断空和满

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

3.用tag标记判断空和满

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

返回队头元素：

1.用牺牲一个节点为代价判断空和满

bool GetHead(SqQueue &Q,int &x){
	if((Q.rear+1) % MaxSize == Q.front)
		return false;
	x = Q.data[Q.front];
	return true;
}

2.用size标记判断空和满

bool GetHead(SqQueue &Q,int &x){
	if(Q.size == 0)
		return false;
	x = Q.data[Q.front];
	return true;
}

3.用tag标记判断空和满

bool GetHead(SqQueue &Q,int &x){
	if((Q.rear+1) % MaxSize == Q.front && tag == 0)
		return false;
	x = Q.data[Q.front];
	return true;
}
千寻瀑༄
关注
  • 6
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构C语言-顺序队、链队的定义、销毁及出入栈操作
T1cH9的博客
07-03 574
学习自用
数据结构10：顺序循环队列
qq_70132617的博客
05-18 963
摘要： 在我们已知队列的最大长度时，可以使用顺序表来进行队列的相关操作。但是，顺序队列会有一个较大的问题，即数组的“假”溢出。我们画一个图来看一下。 我们注意到，在出队操作后，数组其实是还有空间的，但是由于顺序表的单向性，rear指针已经指向了最后，代表了数组空间满了。这就是数组的“假”溢出现象。 对于，我们就可以用到今天要讲的顺序循环队列，实现队该数组空间的最大利用。图示如下 这就很好了，循环队列rear可以回到前面，假溢出现象就不复存在了，最大化的利用数组空间 一.代码块 是这样，由于rear要指向数
数据结构----队列：顺序队列&顺序循环队列、链式队列、顺序优先队列
程序员们必读的博客，涵盖IT技术、编程经验等领域。
08-06 3630
一、队列的概念： 　　队列（简称作队，Queue）也是一种特殊的线性表，队列的数据元素以及数据元素间的逻辑关系和线性表完全相同，其差别是线性表允许在任意位置插入和删除，而队列只允许在其一端进行插入操作在其另一端进行删除操作。 队列中允许进行插入操作的一端称为队尾，允许进行删除操作的一端称为队头。队列的插入操作通常称作入队列，队列的删除操作通常称作出队列。 下图是一个依次向队列中插入数据元素a......
LeetCode 数据结构刷题记录
weixin_46559458的博客
12-12 497
LeetCode 数据结构刷题记录 LeetCode 数据结构 剑指 Offer 05 方法一： 遍历添加 在python和Jave等语言中，字符号都被设计为【不可变】的类型，即无法直接修改字符串的某一位字符，需要新建一个字符串实现。 算法流程 1.初始化一个list，记为res： 2.遍历列表s中的每个字符c； 当c为空格时：向res后添加字符串“%20”； 当c不为空格时：向res后添加字符c； 3.将列表res转化为字符串并返回。 复杂度分析： 时间复杂度O(N): 遍历使用O(N)，每轮添加(
数据结构之——队列详解
最新发布
2302_81016149的博客
05-12 1192
我们前面已经学习了栈，今天我们来学习队列，队列和栈一样，相对来说比较简单，随后，会为大家准备OJ练习题，敬请期待！只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出进行插入操作的一端称为队尾进行删除操作的一 端称为队头这里简单给大家解释一下：大家肯定都排过队（别说没有，我不信），大家在排好队先前前进时，是不是先站到队伍里的先走。队列的原理何其类似。因为，你可以猜一猜它为什么叫队列。可用下面图片帮助大家理解。明白了，基础知识，那就一起来实现一下队列吧。
《数据结构》——顺序、循环、双端、链队列的知识普及
博樽
09-15 489
顺序队列、循环队列、链队列、双端队列的介绍与逻辑代码。
【循环队列之顺序结构】
qq_39842609的博客
05-15 421
队列的定义：相信在使用电脑的时候都有过相似的精力，电脑有时会处于疑似死机的状态，鼠标无论点什么似乎都没用，打开文件也打不开。但是当你失去耐心，打算 重启电脑 时。突然它像酒醒了一样，把你刚才点击的所有操作全部都按顺序执行了一遍。这其实是因为操作系统中的多个程序因需要通过一个通道输出，而按先后次序排队等待造成的。再比如像移动、联通、电信等客服电话，客服人员与客户相比总是少数，在所有的客服人员都占线的情况下，客户会被要求等待，直到有某个客服人员空下来，才能让最先等待的客户接通电话。
数据结构之循环顺序队列
05-30
循环顺序队列是数据结构中的一种，尤其在处理大量数据的输入输出时，它的效率和灵活性显得尤为重要。循环顺序队列是对普通顺序队列的改进，解决了顺序队列在满时无法继续插入元素，空时无法继续删除元素的问题。 ...
C++数据结构之实现循环顺序队列
12-31
数据结构–用C++实现循环顺序队列 队列的操作特性：先进先出 队列中元素具有相同类型 相邻元素具有前驱和后继关系 设置队头、队尾两个指针，以改进出队的时间性能 约定：队头指针front指向队头元素的前一个位置...
循环队列数据结构
07-03
本代码在visual studio enterprise 2015 测试通过，请用户自行调试。若在其它编译器上调试，请将里面的scanf_s改回scanf。
头歌数据结构循环队列及链队列的基本操作
05-18
在本文中，我们将深入探讨头歌数据结构中的两种基本数据结构——循环队列和链队列，以及它们在实现过程中的基本操作。首先，我们来理解这两种数据结构的概念。 循环队列是一种线性数据结构，它模拟了现实生活中的...
java实现顺序队列和循环队列
一眼半生筹
08-11 682
1、顺序队列 public class Queue { public static void main(String[] args) { // TODO Auto-generated method stub queueDemo queueDemo = new queueDemo(4); queueDemo.addQueue(1); queueDemo.addQueue(2); queueDemo.addQueue(3); queueDemo.addQueue(4); queu
建立队列的顺序存储结构（循环队列），进行入队和出队的操作
weixin_46443427的博客
10-28 5939
建立队列的顺序存储结构（循环队列），进行入队和出队的操作 首先我们先说一下队列的基本函数操作（c++） 头文件 #include<queue> 建立一个队列 数据类型 变量名 queue<int> q; 1、检验队列是否为空 empty() 堆栈为空则返回真 q.empty(); 2、返回队首元素 front() 返回队首元素 int result=q.front(); 3、返回队尾元素 back()返回队尾元素 int result=q.back(); 4、弹出队首元素
数据结构——队列的定义与顺序实现（初始化，入队，出队，获取队头元素，判空，判满）C/C++实现
m0_63339166的博客
10-05 1616
2.大胆的将rear指向的那块内存单元存入数据，则变成rear == front,那么就导致队空和队满时rear == front条件一样，无法判断。即栈满的条件是：rear的下一个指向是front了，但此时会浪费掉一个内存单元，即此时rear指向的这个。但是这种判断队满的方式浪费了一个存储单元（即栈满时rear所指向的这个单元不会再放数据） ，为解决这个问题，以下两种判断队满的方式）就可以通过新的方式判空（size == 0）,判满（size == MAX_BUF) ，队内元素个数为size;
【数据结构】队列(顺序队列、循环队列、链队列）
热门推荐
Jacky_Feng的博客
09-15 3万+
文章目录 前言 一、队列的定义 二、队列的顺序存储结构 1.顺序队列的定义 2.循环队列定义 3.循环队列的基本操作 三、队列的链式存储结构 1.链队列的定义 2.链队列的基本操作 前言 队列也是一种线性表，其特殊性在于队列的基本操作是线性表的子集。队列按“先进先出”的规则进行操作，故称其为操作受限的线性表。 一、队列的定义 队列（queue）是只允许在一端进行插入操作，在另一端进行删除操作的线性表，简称“队”。 队列是一种先进先出（First In First Out）的
《数据结构初阶》实现顺序循环队列和链式队列
m0_62171658的博客
03-28 4078
数组实现循环队列、单链表实现队列接口实现全解
循环队列的基本操作
苍之羽
01-25 1万+
为了解决顺序队列假溢出的问题，我们采用的方案是少用一个元素空间，此时的指针状态是队尾指针加1才与队头指针重合，于是此时队满的判定条件变为（rear+1）%MAXSIZE=front,队空的判定条件依然是front==rear,这样就能区分出来是队满还是队空状态了。 一、循环队列的定义： #include&amp;amp;lt;stdio.h&amp;amp;gt; #include&amp;amp;lt;stdlib.h&amp;amp;gt; #includ...
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;
（图解）循环队列的三种判断队空、队满操作（附带源码和插入删除操作等一些基本操作）
在夜里行走的博客
10-15 2万+
一万字图解循环队列附带测试程序的源码
数据结构：顺序循环队列与栈的实现解析
顺序循环队列是数据结构中的重要组成部分，它结合了栈和队列的特点，以循环的方式管理元素，使得在有限的空间内高效地进行数据的入队和出队操作。本章节主要探讨的是栈和队列的基本概念、特性以及实现方法。 栈是一...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值