数据结构之SWUSTOJ965循环队列and Leetcode622设计循环队列。对循环队列的一点思考。(数组和链表两种方式实现循环队列)

最新推荐文章于 2023-11-25 17:09:46 发布
最新推荐文章于 2023-11-25 17:09:46 发布
阅读量1.3k 收藏 16
点赞数 7
分类专栏： 数据结构SWUSTOJ 数据结构 官方OJ 文章标签： 算法 visual studio c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_56054625/article/details/124180821
版权

今天在刷学校OJ题目的时候做到了这道关于循环队列的题目，说实话这个题刚开始真的没有任何思路，实在是想不出来很好的解决办法，但是当我想起一道在LeetCode上做的一道循环队列的题目时突然对循环队列这个东西有了一点思考，但是即使是做过LeetCode的这道题也还是没能想起这个题重点思路，所以决定好好把循环队列的解题方法和关键思路重新巩固梳理一下。

题目：

学校的OJ题目已经把难度降低了很多，但是题目描述还是有一些模糊，但是这里的输入判断方式需要注意一下，入队和出队都只需要判断第一个字符就可，这题的思路不做过多的介绍，因为大致都是仿照LeetCode上面的这题，基本思路一模一样，后面会对LeetCode的题目进行思路分析。

代码：

#include<iostream>
using namespace std;
typedef struct SList
{
	int* data;
	int n;//空间个数，注意实际放的元素个数是n-1个
	int front;
	int rear;
}SL;
SL* SListCreate(int n)
{
	SL* p = (SL*)malloc(sizeof(SL));
	p->n = n;
	p->data = (int*)malloc(sizeof(int)*n);
	p->front = 0;
	p->rear = 0;
	return p;
}
bool IsQueueFull(SL* ps)//判断队列是否为满
{
	if ((ps->rear + 1) % ps->n == ps->front)//队列为满的判断条件
		return true;
	else
		return false;
}
bool IsQueueEmpty(SL* ps)//判断队列是否为空
{
	if (ps->rear == ps->front)
		return true;
	else
		return false;
}
void  SListOperation(SL* ps)
{
	char a[5] = { 0 };//用第一个字符判断是入队操作还是出队操作
	cin >> a;
	if (a[0] == 'i')
	{
		//说明要入队
		int val;
		cin >> val;
		if (!IsQueueFull(ps))//入队前先判满
		{
			ps->data[ps->rear] = val;
			ps->rear++;
			ps->rear = (ps->rear) % (ps->n);//防止越界
		}
	}
	else if(a[0] == 'o')
	{
		//说明要出队
		if (!IsQueueEmpty(ps))//入队前先判空
		{
			ps->front++;
			ps->front = (ps->front) % (ps->n);//防止越界
		}
	}
}
void SListPrint(SL* ps)//剩下队列元素的打印
{
	while (ps->front != ps->rear)
	{
		printf("%d ", ps->data[ps->front]);
		ps->front++;
		ps->front = (ps->front) % (ps->n);
	}
}
int main()
{
	int n = 0;
	cin >> n;
	SL* ret = SListCreate(n);
	int k = 0;
	cin >> k;
	while (k)
	{
		SListOperation(ret);
		k--;
	}
	SListPrint(ret);
	return 0;
}

622. 设计循环队列 - 力扣（LeetCode） (leetcode-cn.com)https://leetcode-cn.com/problems/design-circular-queue/

用数组的方式实现循环队列：

先来看一看用数组实现循环队列的代码，下面的代码注释比较少，如果代码不好理解，下面的图解思路一定可以解开你的疑惑！

typedef struct 
{
    int* a;
    int k;//队列长度为k
    int front;//头的下标
    int rear;//尾的下标
} MyCircularQueue;
bool myCircularQueueIsEmpty(MyCircularQueue* obj) 
{
    if(obj->front==obj->rear)
        return true;
    else
        return false;
}
bool myCircularQueueIsFull(MyCircularQueue* obj) 
{
    if((obj->rear+1)%(obj->k+1)==obj->front)
        return true;
    else
        return false;
}
MyCircularQueue* myCircularQueueCreate(int k) 
{
    MyCircularQueue* q=(MyCircularQueue*)malloc(sizeof(MyCircularQueue));//先给结构体开空间
    q->a=(int*)malloc(sizeof(int)*(k+1));//开k+1个数组空间
    q->front=q->rear=0;//给front和rear赋初值0
    q->k=k;

    return q;
}
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) 
{
    if(myCircularQueueIsFull(obj))
    {
        return false;
    }
    else
    {
        obj->a[obj->rear]=value;
        obj->rear++;
        obj->rear=obj->rear%(obj->k+1);//防止tail越界
        return true;
    }
}
bool myCircularQueueDeQueue(MyCircularQueue* obj)
{
   if(myCircularQueueIsEmpty(obj))
        return false;
    else
    {
        obj->front++;
        obj->front=obj->front%(obj->k+1);
        return true;
    }
}
int myCircularQueueFront(MyCircularQueue* obj) 
{
    //这一步非常容易忽略，但是题干中也有明确地提示到
    if(myCircularQueueIsEmpty(obj))
        return -1;
    else
    {
        return obj->a[obj->front];
    }
}

int myCircularQueueRear(MyCircularQueue* obj) 
{
    if(myCircularQueueIsEmpty(obj))
        return -1;
    else
    {
        //return obj->a[obj->rear-1];//第一直觉的写法，思考这里有什么问题
        int i=(obj->rear+obj->k)%(obj->k+1);
        return obj->a[i];
    }
}
void myCircularQueueFree(MyCircularQueue* obj) 
{
   free(obj->a);//应当先将a这块开辟的空间free掉，也很容易忽略
   free(obj);//再free掉这个结构体空间
}

思路：当我们刚开始拿到这个题的时候，如果对循环队列没有概念的情况下，第一反应大家都一定会去想，需要存放k个数据，我们应该怎么去开辟内存空间呢？我在思考这个题目的时候，也真的是没能想到去开辟k+1个空间的办法，那么知道这个开辟办法过后，我们应当去思考这样设计的目的是什么？为什么设计k个空间行不通呢？

·第一步，也就是我们需要首先正确并且合理地去创建一个结构体，保证在建立这个结构体里面包含的一些内容在每个函数接口都各有各的作用，并且不可或缺，十分重要！下面就来看一看我的这个设计思路：

typedef struct 
{
    int* a;
    int k;//队列长度为k
    int front;//头的下标
    int rear;//尾的下标
} MyCircularQueue;

因为是创建一个数组实现的循环队列，那么首先，我们需要创建一个front位置的下标，用于记录出队列的那个下标，需要用上一个rear位置的下标，用于记录每一次入队列的位置坐标，最后呢这个队列长度k呢，因为题目中只有myCircularQueueCreate这个接口提供了k的值，但是我们后面还需要使用这个k值，那么我们将k存入这个结构体中，以后每一次使用直接从结构体去取即可。

·第二步

结构体建立好了我们就需要思考队列的创建问题了。

MyCircularQueue* myCircularQueueCreate(int k) 
{
    MyCircularQueue* q=(MyCircularQueue*)malloc(sizeof(MyCircularQueue));//先给结构体开空间
    q->a=(int*)malloc(sizeof(int)*(k+1));//开k+1个数组空间
    q->front=q->rear=0;//给front和rear赋初值0
    q->k=k;

    return q;
}

上面这段代码中，先给结构体开辟空间，front和rear赋初值都给0，然后k赋值给结构体中的k。以上三个步骤不容易出错。但是这个数组却开辟了k+1个空间？这是为何呢？接下来画图说明一下：

上面的思路证明了如果我们开辟k个空间来存放k个数据设计循环队列明显是行不通的，那么我们就要换个思路。大家可以联系以下生活实际，比如说，队列在什么时候起到关键作用，他的意义是什么。两个关键词：判断队列是否为空！判断队列是否为满                   

为了可以实现判空和判满，我们需要设计一个新的开辟空间的思路，下面通过一封图来理解一下：

通过上图可以看出需要判空和判满我们则需要开辟k+1个空间来实现循环队列，那么我们再来举一个具体的实例看看：

 通过上面的实例就可以完成对判空判满两个接口函数的实现：

bool myCircularQueueIsEmpty(MyCircularQueue* obj) 
{
    if(obj->front==obj->rear)
        return true;
    else
        return false;
}
bool myCircularQueueIsFull(MyCircularQueue* obj) 
{
    if((obj->rear+1)%(obj->k+1)==obj->front)
        return true;
    else
        return false;
}

·第三步：实现完判空和判满接下来我们就需要来写一写入队和出队的接口了。

依旧通过具体的例子来看看：

 

通过上面图解的分析，我们就可以完成入队和出队接口函数的代码：

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) 
{
    if(myCircularQueueIsFull(obj))
    {
        return false;
    }
    else
    {
        obj->a[obj->rear]=value;
        obj->rear++;
        obj->rear=obj->rear%(obj->k+1);//防止tail越界
        return true;
    }
}
bool myCircularQueueDeQueue(MyCircularQueue* obj)
{
   if(myCircularQueueIsEmpty(obj))
        return false;
    else
    {
        obj->front++;
        obj->front=obj->front%(obj->k+1);
        return true;
    }
}

·第四步：完成了入队出队操作后，我们接下来看看如何去找到队首的元素和队尾的元素，注意这里有一个这题非常容易出错的点！

 接下来就可以完成我们队首元素和队尾两个元素的接口函数代码：

int myCircularQueueFront(MyCircularQueue* obj) 
{
    //这一步非常容易忽略，但是题干中也有明确地提示到
    if(myCircularQueueIsEmpty(obj))
        return -1;
    else
    {
        return obj->a[obj->front];
    }
}

int myCircularQueueRear(MyCircularQueue* obj) 
{
    if(myCircularQueueIsEmpty(obj))
        return -1;
    else
    {
        //return obj->a[obj->rear-1];//第一直觉的写法，思考这里有什么问题
        int i=(obj->rear+obj->k)%(obj->k+1);
        return obj->a[i];
    }
}

·第五步：最后还需要写一个释放空间的代码：

这里也需要注意一下！

释放空间的时候，应当首先去释放开辟的数组空间，再去释放结构体！

这里的先后顺序不能搞反了！

因为一旦先释放掉结构体后，就没法去找到开辟的数组了，所以要记得先释放malloc开辟的数组，然后再释放结构体！

void myCircularQueueFree(MyCircularQueue* obj) 
{
   free(obj->a);//应当先将a这块开辟的空间free掉，也很容易忽略
   free(obj);//再free掉这个结构体空间
}

用链表的方式实现循环队列：

首先还是先来看看代码：

typedef struct SList
{
    int data;
    struct SList* next;
}SL;
typedef struct 
{
    int k;
    SL* front;
    SL* rear;
} MyCircularQueue;

MyCircularQueue* myCircularQueueCreate(int k) 
{
    MyCircularQueue* q=(MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    SL* cur=(SL*)malloc(sizeof(SL));
    q->k=k;
    q->front=cur;
    q->rear=cur;
    while(k)
    {
        SL* newnode=(SL*)malloc(sizeof(SL));//开辟一个新节点
        cur->next=newnode;
        cur=newnode;
        cur->next=q->front;
        k--;
    }//在入队出队之前首先要把空间所有的节点都开辟好，只是不存放有效数据而已
    return q;
}
bool myCircularQueueIsEmpty(MyCircularQueue* obj) 
{
    if(obj->front==obj->rear)
        return true;
    else
    return false;
}
bool myCircularQueueIsFull(MyCircularQueue* obj) 
{
    if(obj->rear->next==obj->front)
        return true;
    else
        return false;
}
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) 
{
    if(myCircularQueueIsFull(obj))
        return false;
    else
    {
        obj->rear->data=value;
        obj->rear=obj->rear->next;
        return true;
    }
}

bool myCircularQueueDeQueue(MyCircularQueue* obj) 
{
    if(myCircularQueueIsEmpty(obj))
        return false;
    else
    {
        obj->front=obj->front->next;
        return true;
    }
}

int myCircularQueueFront(MyCircularQueue* obj) 
{
    if(myCircularQueueIsEmpty(obj))
        return -1;
    else
        return obj->front->data;
}

int myCircularQueueRear(MyCircularQueue* obj) 
{
    if(myCircularQueueIsEmpty(obj))
        return -1;
    else
    {
        SL* prev=obj->front;
        while(prev->next!=obj->rear)
        {
            prev=prev->next;
        }
        return prev->data;
    }
}
void myCircularQueueFree(MyCircularQueue* obj) 
{
    while(obj->front!=obj->rear)
    {
        SL* cur=obj->front->next;
        free(obj->front);
        obj->front=cur;
    }
    free(obj->front);
    free(obj);
}

 

上面分别用数组的方式和链表的方式实现了循环队列的问题，个人认为用链表的方式实现逻辑上更为简单一些，不过在结构体的创建上和空间的开辟方面相对复杂一些。数组的方式在逻辑分析上稍微会多绕一些弯，不过结构体建立空间开辟还算比较简单。两种方法在时空上各有千秋。

最后看完循环队列的两道OJ题后，就在想为什么会有大佬弄出循环队列这个东西，比较好奇其中的原理和设计者的设计目的，所以去查阅了一下相关的大神博客关于循环队列的文章。

循环队列是队列的一种顺序存储结构。循环队列的引入，目的是为了克服假溢出时大量移动数据元素 。 

循环队列的优点是相对于直线队列来讲的，直线队列在元素出队后，头指针向后移动，导致删除元素后的空间无法在利用，即使元素个数小于空间大小，依然无法再进行插入，即所谓的“假上溢”。 当变成循环队列之后，删除元素后的空间仍然可以利用，最大限度的利用空间。

1、循环队列的优点：
　　可以有效的利用资源。用数组实现队列时，如果不移动，随着数据的不断读写，会出现假满队列的情况。即尾数组已满但头数组还是空的；循环队列也是一种数组，只是它在逻辑上把数组的头和尾相连，形成循环队列，当数组尾满的时候，要判断数组头是否为空，不为空继续存放数据。
　　2、循环队列的缺点：
　　循环队列中，由于入队时尾指针向前追赶头指针；出队时头指针向前追赶尾指针，造成队空和队满时头尾指针均相等。因此，无法通过条件front==rear来判别队列是"空"是"满"。
　　3、拓展知识：
　　为充分利用向量空间，克服"假溢出"现象的方法是：将向量空间想象为一个首尾相接的圆环，并称这种向量为循环向量。存储在其中的队列称为循环队列。

~|Bernard|
关注
  • 7
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 5
    评论
专栏目录
OJ.zip_循环链表
09-21
循环链表解决热土豆（约瑟夫）问题，简单易懂，可以直接修改
LeetCode OJ循环队列（C语言）
sqm_C的博客
11-25 1319
我们分析上述题目的时候会发现题目非常的长，不好整理思路，我这里可以大致的将本题的几个核心点说出来：1.队列的思路循环队列说来说去不还是队列嘛，那么队列的基本操作增删查改、以及队列的基本结构肯定都是不能变的，我们知道队列的逻辑结构就是先进先出，而在C语言中，我们要实现队列可以采用两种方法，一种是链表，一种是顺序表，本题我们采用顺序表。2.循环的实现。
SWUST OJ#943(数据结构之顺序表插入操作的实现)
weixin_62268437的博客
03-26 2162
目录 题目 思路 代码 数据结构 STL解法 题目描述 建立长度为n的顺序表，在指定的数据元素item之前插入数据元素data。如果指定的数据元素item不存在，则将data插入到顺序表的尾端。（数据类型为整型） 输入 第一行为顺序表的长度n； 第二行为顺序表中的数据元素； 第三行为指定的数据元素item； 第四行为要插入的数据元素data； 样例输入 10 10 20 30 40 50 60 70 80 90 100 50 55 样例...
SWUST OJ#1103(数据结构之删除顺序表中指定区间的数据)
weixin_62268437的博客
03-27 2736
目录 题目 思路 代码 题目 题目描述 建立顺序表L，将指定区间的数据从顺序表中删除。假设指定区间是合法数据，无序做合法性判断。测试数据为整型。 输入 第一行是表长n；第二行是表中数据元素；第三行是闭区间。 输出 删除以后的顺序表中的数据元素。 样例输入 10 22 32 11 23 43 59 17 65 45 57 10 20 样例输出 22 32 23 43 59 65 45 57 思路 思路一：每删除一个在区间的值，然...
DS_Queue
m0_61758697的博客
09-21 1091
其中Queue/* 存储元素的数组 *//* 队列的头指针 */int Count;/* 队列中元素个数 *//* 队列最大容量 */};注意：如果队列已满，AddQ函数必须输出“Queue Full”并且返回false；如果队列是空的，则DeleteQ函数必须输出“Queue Empty”，并且返回ERROR。/* 存储元素的数组 *//* 队列的头、尾指针 *//* 队列最大容量 */};其中Deque/* 存储元素的数组 *//* 队列的头、尾指针 */
965: 循环队列
m0_57042870的博客
03-04 152
【代码】965: 循环队列。
循环队列（进队，出队）
qq_19266669的博客
05-13 957
描述 根据给定的空间构造顺序循环队列，规定队满处理方法为少用一个元素空间。例如，给定5个元素空间构造循环队列，则只能存放4个元素。试根据入队及出队操作判断队列最后的元素存放情况，并输出最后队列中的元素值，即完成给定入队及出列操作后一次性全部出队的元素值。要求采用顺序队列完成。 输入 输入的第一行为一个自然数n，表示要求构造的顺序循环队列空间数。第二行为操作次k，接下来k行为出队入队...
数据结构之循环队列
吃葡萄不吐葡萄皮
08-02 2806
描述 根据给定的空间构造顺序循环队列，规定队满处理方法为少用一个元素空间。例如，给定5个元素空间构造循环队列，则只能存放4个元素。试根据入队及出队操作判断队列最后的元素存放情况，并输出最后队列中的元素值，即完成给定入队及出列操作后一次性全部出队的元素值。要求采用顺序队列完成。 输入 输入的第一行为一个自然数n，表示要求构造的顺序循环队列空间数。第二行为操作次k，接下来k行
数据结构-循环队列详解（c语言版）
m0_55698213的博客
10-27 2503
本文主要介绍了循环队列的一些概念特点和C语言代码实现以及一些应用场景。
循环队列的判满和判空方法
weixin_54046648的博客
08-11 1286
前面指出了顺序队列的缺点，这里引出循队列的概念。将顺序队列臆造为一个环状的空间，即把存储队列元素的表从逻辑上视为一个环，称为循环队列。
leetcode23合并k个有序链表。优先队列（最小堆）python 代码+思路
12-22
暴力解法有两种，一种是12排，然后和3，然后和4，继续下去； 另一种是先放到一个数组中进行排序，然后按照顺序连接 分而治之：两两合并 如果有k个链表，平均每个链表有n个节点 那么，第一轮，k/2次，每次2n个节点 第...
leetcode添加元素使和等于-Data-Structures:数据结构学习实现+动态数组+栈+链表+二分搜索树+集合+映射+优先队列+堆+
06-30
leetcode添加元素使和等于 简单的复杂度分析 O(1)、O(n)、O(lgn)、O(nlogn)、O(n^2) 大O描述的是算法的运行时间和输入数据之间的关系 public static int sum(int[] nums) { int sum = 0; for (int num: nums) sum +=...
Leetcode刷题（20）栈和队列的基本应用：用队列实现栈
01-20
题目分析： 这题主要考察对于栈和队列性质的理解，他们的本质不同就在于元素进入和弹出的顺序，完全相反。栈是 Last In First Out (LIFO), 队列是 Fisrt In First Out (FIFO), 实现起来有点变扭。 解法： class ...
LeetCode判断字符串是否循环-Data-Structures-and-Algorithms:记录学习数据结构与算法的笔记
07-01
LeetCode判断字符串是否循环 Data-Structures-and-Algorithms 记录学习数据结构与算法的笔记 刷题记录在leetcode目录下 链表相关题目 19: 删除链表倒数第 n 个结点 21: 合并两个有序链表 141: 判断链表中是否有环 ...
leetcode数组下标大于间距-algorithm_java:实现数据结构和算法
06-30
主要包括数据结构的java实现 1.数组 2.并查集 3.图 4.链表 5.队列 6.栈 7.树 divide_conquer:分治 1.活动选择问题 2.输入一个整形数组，数组里有正数也有负数。数组中连续的一个或多个整数组成一个子数组，每个子...
设计循环队列(OJ)
最新发布
2301_77838258的博客
11-25 962
方法一:使用size计数,size为0即为空,size与队容量相等即为满,使用余数计算存放位置 方法二:多开一个空间,比如要求5个空间,我们开6个空间,那么队头等于队尾即为空,队头的上一个为队尾即为满,使用余数计算存放位置
c语言中循环队列的优点,循环队列的优点是什么？
weixin_30998047的博客
05-22 854
满意答案cowkinki2013.07.04采纳率：44%等级：12已帮助：7278人有个设了队头，队尾的，你参考下，入队的时候队尾指针变，出队的时候队头指针变int EnQueue(CirQueue *Q, DataType e)//入队{if (Q->quelen == QueueSize) //队满条件{printf("Queue is full! Cannot EnQueue...
OJ题：设计一个循环队列
LiangXiay的博客
11-01 445
(本题取自LeetCode622.设计循环队列) 1.题目介绍 循环队列是指一种线性的数据结构，该结构遵循先进先出的原则，并且队尾则被连接在队首之后以形成一个循环。 循环队列可以循环使用队列之前用过的空间，普通队列的头元素前的节点不能再使用，而循环队列可以在队列没有满之前循环的使用空间。 对于循环队列我们需要支持如下的操作： 1.构造一个队列长度为k的循环队列 2.从队首获取元素，若队列为空则返回-1 3.获取队尾元素，若队列为空则返回-1 4.向循环队列插入一个元素，若成功插入则返回.
数据结构之SWUSTOJ1044: 顺序栈基本操作的实现
weixin_56054625的博客
04-10 746
题目： 代码: #include<stdio.h> #include<stdlib.h> typedef struct Stack { int* data; int top;//栈顶元素坐标 int capacity;//栈的容量 }ST; void STInit(ST* ps) { ps->data = NULL; ps->top = 0;//ps->top=-1; //初始化时top给0，意味着top指向栈顶数据的下一个 //初始化.
数据结构leetcode刷题顺序
10-08
1. 数组和字符串：这是最基础的数据结构，包括数组和字符串的操作和处理。 2. 链表：理解链表的特点和基本操作，如插入、删除、反转等。 3. 栈和队列：了解栈和队列的特点和应用，如使用栈实现队列、使用栈解决问题...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

~|Bernard|

你的鼓励是我写下去最大的动力

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

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

打赏作者

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

抵扣说明：

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

余额充值