设计循环队列 - OJ题

最新推荐文章于 2024-05-21 19:00:05 发布
最新推荐文章于 2024-05-21 19:00:05 发布
阅读量445 收藏 4
点赞数 6
分类专栏： C语言 文章标签： c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_58724706/article/details/121128998
版权

目录

题目描述

示例

提示

题目分析

结构体的创建 

函数接口的创建

MyCircularQueue* myCircularQueueCreate(int k)

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value)

bool myCircularQueueDeQueue(MyCircularQueue* obj)

int myCircularQueueFront(MyCircularQueue* obj)

int myCircularQueueRear(MyCircularQueue* obj)

bool myCircularQueueIsEmpty(MyCircularQueue* obj)

bool myCircularQueueIsFull(MyCircularQueue* obj)

void myCircularQueueFree(MyCircularQueue* obj)

完整代码

题目描述

设计你的循环队列实现。 循环队列是一种线性数据结构，其操作表现基于 FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。

循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里，一旦一个队列满了，我们就不能插入下一个元素，即使在队列前面仍有空间。但是使用循环队列，我们能使用这些空间去存储新的值。

你的实现应该支持如下操作：

MyCircularQueue(k): 构造器，设置队列长度为 k 。
Front: 从队首获取元素。如果队列为空，返回 -1 。
Rear: 获取队尾元素。如果队列为空，返回 -1 。
enQueue(value): 向循环队列插入一个元素。如果成功插入则返回真。
deQueue(): 从循环队列中删除一个元素。如果成功删除则返回真。
isEmpty(): 检查循环队列是否为空。
isFull(): 检查循环队列是否已满。

示例

MyCircularQueue circularQueue = new MyCircularQueue(3); // 设置长度为 3
circularQueue.enQueue(1);  // 返回 true
circularQueue.enQueue(2);  // 返回 true
circularQueue.enQueue(3);  // 返回 true
circularQueue.enQueue(4);  // 返回 false，队列已满
circularQueue.Rear();  // 返回 3
circularQueue.isFull();  // 返回 true
circularQueue.deQueue();  // 返回 true
circularQueue.enQueue(4);  // 返回 true
circularQueue.Rear();  // 返回 4

提示

  • 所有的值都在 0 至 1000 的范围内；
  • 操作数将在 1 至 1000 的范围内；
  • 请不要使用内置的队列库。

题目分析

在这个循环队列里面我们知道我们将要插入k个元素。

我们在插入数据和删除数据要分别判断循环队列是否满了和是否有数据，这时候我们需要开辟k+1个节点的空间。否则，就无法区分是否满了或者队列中是否有数据。

1、判断循环列中是否为空：front == tail   //当两个下标相等时就说明没有数据了。

        

 2、判断循环循环队列中是否满了：当tail的下一个坐标是front时，说明就满了。即：

     (tail+1)%(k+1)==front，如图两种情况：

       

结构体的创建 

typedef struct
{
    int* a;
    int front;
    int tail;
    int k;
} MyCircularQueue;

typedef struct
{
    int* a;//指向一块连续的物理空间
    int front;//记录头数据
    int tail;//记录尾数据
    int k; //记录存储数据的个数
} MyCircularQueue;

函数接口的创建

MyCircularQueue* myCircularQueueCreate(int k)

MyCircularQueue* myCircularQueueCreate(int k)
{
    MyCircularQueue* cq = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    if (cq == NULL)
    {
        printf("malloc fail\n");
        exit(-1);
    }
    cq->a = (int*)malloc(sizeof(int) * (k + 1));
    cq->front = cq->tail = 0;
    cq->k = k;
    return cq;
}

循环队列初始化

MyCircularQueue* myCircularQueueCreate(int k)
{
    MyCircularQueue* cq = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));//开辟一个空间来存放一个结构体
    if (cq == NULL) //判断是否开辟成功
    {
        printf("malloc fail\n");
        exit(-1);
    }
    cq->a = (int*)malloc(sizeof(int) * (k + 1));//开辟(k+1)个结点
    cq->front = cq->tail = 0;//头和尾的下标都先初始化成0
    cq->k = k; //记录存储数据的个数
    return cq;//返回这个结构体的地址
}

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value)

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value)
{
    assert(obj);
    if (myCircularQueueIsFull(obj))
    {
        return false;
    }
    obj->a[obj->tail] = value;
    obj->tail++;
    obj->tail %= (obj->k + 1);
    return true;
}

插入数据（从tail开始加）

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value)
{
    assert(obj);
    if (myCircularQueueIsFull(obj)) //判断循环队列中是否满了
    {
        return false; //满了，就不增加了，返回假（0）

这种情况如图：


    }
    obj->a[obj->tail] = value; //tail坐标地方赋值要插入的值
    obj->tail++;//tail加1
    obj->tail %= (obj->k + 1); //tail加1后进行这样的操作，是为了保证队列的循环。

第一种情况：

        
第二种情况，当tail在末位置时：   

 

       

return true;
}

bool myCircularQueueDeQueue(MyCircularQueue* obj)

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

删数据（从front位置开始删）

bool myCircularQueueDeQueue(MyCircularQueue* obj)
{
    assert(obj);
    if (myCircularQueueIsEmpty(obj)) //如果循环队列中为空时，就返回假
    {
        return false;
    }
    obj->front++;//front加1，这样最初的第一个位置就访问不到了，相当于头删了
    obj->front %= (obj->k + 1);//front加1后进行这样的操作，是为了保证队列的循环。

第一种情况：

        
第二种情况，当front在末尾时进行删除：

      

  return true;
}

int myCircularQueueFront(MyCircularQueue* obj)

int myCircularQueueFront(MyCircularQueue* obj)
{
    assert(obj);
    if (!myCircularQueueIsEmpty(obj))
    {
        return obj->a[obj->front];
    }
    else
    {
        return -1;
    }
}

int myCircularQueueFront(MyCircularQueue* obj)
{
    assert(obj);
    if (!myCircularQueueIsEmpty(obj))//如果循环队列中不为空时就进去
    {
        return obj->a[obj->front]; //返回值为循环队列中的第一个数据
    }
    else
    {
        return -1;  //如果循环队列中没有数据，根据题意就返回-1
    }
}

int myCircularQueueRear(MyCircularQueue* obj)

int myCircularQueueRear(MyCircularQueue* obj)
{
    assert(obj);
    if (!myCircularQueueIsEmpty(obj))
    {
        int i = (obj->tail + obj->k) % (obj->k + 1);//找tail前一个
        return obj->a[i];
    }
    else
    {
        return -1;
    }
}

返回循环队列最后的一个数据

int myCircularQueueRear(MyCircularQueue* obj)
{
    assert(obj);
    if (!myCircularQueueIsEmpty(obj))//如果循环队列中不为空时就进去
    {
        int i = (obj->tail + obj->k) % (obj->k + 1); //找tail前一个

第一种情况（找下标为4的数据）：

         

第二种情况，tail在下标为0的位置处(即下标为5里面的数据)：

          

由此，我们针对这种情况我们可以把这个条件进行改写： 

    

return obj->a[i];
    }
    else
    {
        return -1;
    }
}

bool myCircularQueueIsEmpty(MyCircularQueue* obj)

bool myCircularQueueIsEmpty(MyCircularQueue* obj)
{
    assert(obj);
    return obj->front == obj->tail;
}

判断循环队列中是否为空

bool myCircularQueueIsEmpty(MyCircularQueue* obj)
{
    assert(obj);
    return obj->front == obj->tail;//当front和tail相等时就为空
}

           

bool myCircularQueueIsFull(MyCircularQueue* obj)

bool myCircularQueueIsFull(MyCircularQueue* obj)
{
    assert(obj);
    return (obj->tail + 1) % (obj->k + 1) == obj->front;//当tail的下一个是front时，就满了
}

bool myCircularQueueIsFull(MyCircularQueue* obj)
{
    assert(obj);
    return (obj->tail + 1) % (obj->k + 1) == obj->front;//当tail的下一个是front时，就满了
}

        

void myCircularQueueFree(MyCircularQueue* obj)

void myCircularQueueFree(MyCircularQueue* obj)
{
    assert(obj);
    free(obj->a);
    obj->a = NULL;
    obj->front = obj->tail = 0;
}

销毁循环队列

void myCircularQueueFree(MyCircularQueue* obj)
{
    assert(obj);
    free(obj->a);//释放掉空间
    obj->a = NULL;//置空，防止a还记录已经被销毁的空间的地址，造成野指针的安全隐患
    obj->front = obj->tail = 0;
}

完整代码

#define  _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<assert.h>
#include<stdlib.h>
#include<stdbool.h>
typedef struct
{
    int* a;
    int front;
    int tail;
    int k;
} MyCircularQueue;

bool myCircularQueueIsEmpty(MyCircularQueue* obj);
bool myCircularQueueIsFull(MyCircularQueue* obj);

MyCircularQueue* myCircularQueueCreate(int k)
{
    MyCircularQueue* cq = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    if (cq == NULL)
    {
        printf("malloc fail\n");
        exit(-1);
    }
    cq->a = (int*)malloc(sizeof(int) * (k + 1));
    cq->front = cq->tail = 0;
    cq->k = k;
    return cq;
}

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value)
{
    assert(obj);
    if (myCircularQueueIsFull(obj))
    {
        return false;
    }
    obj->a[obj->tail] = value;
    obj->tail++;
    obj->tail %= (obj->k + 1);
    return true;
}

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

int myCircularQueueFront(MyCircularQueue* obj)
{
    assert(obj);
    if (!myCircularQueueIsEmpty(obj))
    {
        return obj->a[obj->front];
    }
    else
    {
        return -1;
    }
}

int myCircularQueueRear(MyCircularQueue* obj)
{
    assert(obj);
    if (!myCircularQueueIsEmpty(obj))
    {
        int i = (obj->tail + obj->k) % (obj->k + 1);//找tail前一个
        return obj->a[i];
        //if (obj->tail == 0)
        //{
        //    return obj->a[obj->k];
        //}
        //else
        //{
        //    return obj->a[obj->tail - 1];
        //}
    }
    else
    {
        return -1;
    }
}

bool myCircularQueueIsEmpty(MyCircularQueue* obj)
{
    assert(obj);
    return obj->front == obj->tail;
}

bool myCircularQueueIsFull(MyCircularQueue* obj)
{
    assert(obj);
    return (obj->tail + 1) % (obj->k + 1) == obj->front;//当tail的下一个是front时，就满了
}

void myCircularQueueFree(MyCircularQueue* obj)
{
    assert(obj);
    free(obj->a);
    obj->a = NULL;
    obj->front = obj->tail = 0;
}
int main()
{
    int k = 0;
    printf("请输入循环数字的个数：");
    scanf("%d", &k);
    MyCircularQueue* cq = myCircularQueueCreate(k);
    myCircularQueueEnQueue(cq, 1);
    myCircularQueueEnQueue(cq, 2);
    myCircularQueueEnQueue(cq, 3);

    int tmp = myCircularQueueRear(cq);
    printf("%d\n", tmp);
    tmp = myCircularQueueFront(cq);
    printf("%d\n", tmp);
    return 0;
}

测试代码：

暴走的橙子～
关注
  • 6
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
java队列实现（顺序队列、链式队列、循环队列）
07-27
java队列实现（顺序队列、链式队列、循环队列）
【数据结构】队列的实现及应用和循环队列的实现【完整版】
m0_74044018的博客
04-23 1841
讲解队列的概念和实现，队列的应用、队列的几道经典编程题，队列的概念选择题【完整版】
环形队列的基本运算算法-数据结构教程
qq_42818882的博客
11-13 5734
环形队列的基本概念 如图，其实它就是一个队列，就是有点难理解而已，它避免了普通队列的缺点，一样有队列头，队列尾，一样是先进先出的原则。我们采用顺时针的方式来对队列进行排序。 队列头(front) :允许进行删除的一端称为队首。 队列尾(rear) :允许进行插入的一端称为队尾。 环形队列的实现： 在计算机中，是没有环形的内存的，只是我们将顺序的内存处理过，让某一段内存形成环形，使他们首尾相连，简单来说，就是一个数组，只不过有两个指针，一个指向列队头，一个指向列队尾。指向列队头的指针(front)是缓
队列的详细解读
憨憨小江的博客
10-29 382
队列的解读！定义底层实现原理非循环队列循环队列循环队列算法设计示例 定义 定义：操作受限的线性表，添加在一端进行，删除在另一端进行。 特点：先进先出，其中的方法和栈有所类似 底层实现原理 非循环队列 front 指队头 rear 指队尾 队空条件：front == rear 队满条件：rear = Maxsize - 1 我们先写一个队列的泛型类，做一些初始化的操作 class SqQueueClass<E> { final int MaxSize = 100; private
【数据结构】队列、环形队列
vpurple_的博客
08-25 2042
好久不见！这里是媛仔，欢迎光临媛仔的数据结构进阶之路~
循环队列详解
热门推荐
weixin_55858644的博客
01-04 4万+
简单易懂的循环队列
数据结构——循环队列详解
weixin_51785373的博客
10-27 1万+
队列主要有顺序队列，循环队列，双端队列，优先队列。而当中循环队列是一种线性数据结构。它也被称为“环形缓冲器”。它只允许在一端进行插入操作，即队尾（rear），而在另一端进行删除操作，即队头 (front)，其操作表现基于FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环。向队列中插入新的数据元素称为入队，新入队的元素就成为了队列的队尾元素。循环队列允许元素在队尾插入，在队头删除，同时遵循先进先出原则。由于循环队列是基于数组实现的，所以它的访问速度很快，特别是在移动元素时。
循环队列
wkh18891843165的博客
03-07 1万+
队列又称为“先进先出”（FIFO）线性表 插入操作只能在队尾进行，删除操作只能在队首进行 队列也可以采用顺序存储结构和链表结构实现 循环队列只是队列的一种特殊形式 1.循环队列的由来 我们规定，当front == rear表示此队列为空，那么此时下面这个队列就为空队列，而且我们定义rear指向的下标永远可以存放数据 1.1当没有插入数据时 1.2当插入数据之后 1.3当删除数据之后 1.4当再次插入数据后 所以这就引出了我们的循环队列 2.循环队列 2.1当没有插入数据时 此时front==rea
【数据结构】循环队列
不 良的博客
07-07 4176
队列又称为"先进先出（FIFO）"线性表：插入操作只能在队尾进行，删除操作只能在队首进行。而循环队列是队列的一种特殊形式，循环队列（也被称为环形队列）是一种线性数据结构，其操作表现基于先进先出原则，并且队尾被连接在队首之后以形成一个循环。循环队列固定大小，空间能够重复利用。循环队列可以用数组或者链表实现，那下面我们来分析一下哪种方式更好：当我们想使用链表实现时，假设我们想要开辟的队列长度为k = 4；front表示队头指针，rear表示队尾指针：由上图可知，当rear和front 都指向同一个位置时队列为空
cpp代码-双向循环链表-oj
07-14
cpp代码-双向循环链表-oj
毕业设计--OJ用户能力评价.zip
03-02
毕业设计是高等教育阶段学生完成学业的一个重要环节，通常在学士或硕士学业即将结束时进行。这是学生将在整个学业中所学知识和技能应用到实际问题上的机会，旨在检验学生是否能够独立思考、解决问题，并展示其专业...
leetcode题库-OJ:在线裁判
06-29
leetcode题库 注意！（20180803更新） ...OJ做题记录, 包括PAT, LeetCode等题库. tools是备考PAT的一些tips 经典题型 最大连续子列和 KMP 字符串匹配 LCS, Longest Common Substring 大整数运算 LCA dp1 , 全排列
【数据结构与算法 2】循环队列
学Java，找哪吒
05-13 1万+
一、队列 队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。 进行插入操作的端称为队尾，进行删除操作的端称为队头。 队列的数据元素又称为队列元素。在队列中插入一个队列元素称为入队，从队列中删除一个队列元素称为出队。因为队列只允许在一端插入，在另一端删除，所以只有最早进入队列的元素才能最先从队列中删除，故队列又称为先进先出（FIFO—first in first out）线性表。 二、循环队列
数据结构-循环队列(C语言代码)
weixin_50246370的博客
08-14 1997
循环队列就是将队列存储空间的最后一个位置绕到第一个位置，形成逻辑上的环状空间，供队列循环使用。在循环队列结构中，当存储空间的最后一个位置已被使用而再要进入队运算时，只需要存储空间的第一个位置空闲，便可将元素加入到第一个位置，即将存储空间的第一个位置作为队尾。 循环队列可以更简单防止伪溢出的发生，但队列大小是固定的。 在循环队列中，当队列为空时，有front=rear，而当所有队列空间全占满时，也有front=rear。为了区别这两种情况，规定循环队列最多只能有MaxSize-1个队列元素，当循环队列中只剩.
Leetcode：662.Design Circular Queue 设计循环队列
Coding
09-18 903
Design Circular Queue 设计循环队列 设计你的循环队列实现。 循环队列是一种线性数据结构，其操作表现基于 FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。 循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里，一旦一个队列满了，我们就不能插入下一个元素，即使在队列前面仍有空间。但是使用循环队列，我们能使用这些空间去存...
详解循环队列
Lemonflavoredgum的博客
10-27 624
循环队列是一种基于数组实现的队列数据结构，它的特点是队列的尾部指针可以循环到数组的头部，形成一个环形结构。循环队列的定义包括以下几个要素：一个固定大小的数组：循环队列使用一个数组来存储元素，数组的大小是预先指定的。一个头指针（front）：指向队列的第一个元素。一个尾指针（rear）：指向队列最后一个元素的下一个位置。当队列为空时，头指针和尾指针指向同一个位置。队列长度（size）：表示队列中元素的个数。
循环队列（详解）---＞数据结构、C++实现
m0_54158068的博客
03-30 2553
循环队列（详解）--->数据结构（队列）
【LinuxC语言】目录操作
最新发布
m0_62599305的博客
05-21 123
在Linux系统中，目录操作是文件系统管理的重要组成部分。对于使用C语言进行系统编程的开发者来说，熟悉和掌握目录操作函数是必不可少的。这些函数使开发者能够创建、删除、读取和遍历目录，从而实现对文件系统的精细控制。本文将详细介绍Linux系统中C语言用于目录操作的常用函数，涵盖其函数原型、参数、返回值及示例代码，帮助读者全面理解和运用这些函数。Linux系统中，C语言提供了丰富的目录操作函数，使得开发者可以方便地管理和操作文件系统。
nwafu-oj1515
01-15
根据引用[2]中的NWAFU-OJ题解，nwafu-oj1515是一个关于字符串处理的问题。该问题要求统计给定字符串中每个字符出现的次数，并按照字符的ASCII码从小到大的顺序输出结果。 以下是一个解决nwafu-oj1515问题的示例代码...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值