设计循环队列 - OJ题

最新推荐文章于 2023-10-29 11:12:47 发布
最新推荐文章于 2023-10-29 11:12:47 发布
阅读量496 收藏 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;
}

测试代码：

暴走的橙子～
关注
专栏目录
【数据结构】队列详解 && 栈和队列OJ题 —— 用队列实现栈、用栈实现队列、设计循环队列
StackFrame
11-16 1148
队列的概念和结构讲解、C语言实现队列、OJ题 —— 用队列实现栈、用栈实现队列、设计循环队列
栈和队列经典OJ题
MEANSWER的博客
10-05 576
栈和队列经典OJ题1. LeetCode第225题---用队列实现栈2. LeetCode第232题---用栈实现队列3. LeetCode第20题---有效的括号4. LeetCode第150题---逆波兰表达式5. LeetCode第155题---最小栈6. 牛客网剑指offer21题---栈的压入、弹出序列 1. LeetCode第225题—用队列实现栈 链接: https://leetcode-cn.com/problems/implement-stack-using-queues/ 题解：用队列
Leetcode：662.Design Circular Queue 设计循环队列
Coding
09-18 1047
Design Circular Queue 设计循环队列 设计你的循环队列实现。 循环队列是一种线性数据结构，其操作表现基于 FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。 循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里，一旦一个队列满了，我们就不能插入下一个元素，即使在队列前面仍有空间。但是使用循环队列，我们能使用这些空间去存...
数据结构--循环队列
lbaihao的专栏
06-10 674
1. 顺序队列的假溢出&循环队列的概念 我们已经明白了队列这种基本数据结构，对于顺序队列而言，其存在已经足够解决大多时候的设计问题了，但是其依旧存在一些缺陷和不足，因为我们的入队和出队操作均是直接在其后面进行结点的链接和删除，这就造成其使用空间不断向出队的那一边偏移，产生假溢出。 什么是假溢出？打一个比方： （示例顺序队列） 回顾一下队列的性质，首先我们有一个顺序队列，这个队列的大小为5，其已经包含了四个元素data1,data2,data3,data4,接着，我们对这个队列进行出队操作，出
数据结构：循环队列
weixin_30929195的博客
01-04 1831
数据结构：循环队列 写在前面 　　附我的另一篇博客：C_队列的链式表示和描述 数组表示的问题　 　　　　对于队列最好的方法是使用链表实现，因为对于数组来说，队列可能会出现下面这种情况： 　　　 　　　　如图所示，不可以继续添加元素，否则会造成数组越界而遭致程序出错。然而此时又不应该扩充数组，因为还有大量实际空间未被占用。 　　　　此时我们应该如何解决这个问题呢？我们将其实现为...
【数据结构】循环队列
不 良的博客
07-07 4513
队列又称为"先进先出（FIFO）"线性表：插入操作只能在队尾进行，删除操作只能在队首进行。而循环队列是队列的一种特殊形式，循环队列（也被称为环形队列）是一种线性数据结构，其操作表现基于先进先出原则，并且队尾被连接在队首之后以形成一个循环。循环队列固定大小，空间能够重复利用。循环队列可以用数组或者链表实现，那下面我们来分析一下哪种方式更好：当我们想使用链表实现时，假设我们想要开辟的队列长度为k = 4；front表示队头指针，rear表示队尾指针：由上图可知，当rear和front 都指向同一个位置时队列为空
程序设计基础 OJ 题库 NUIST
10-22
WorkSpace文件可能包含了你在OJ平台上做题时的工作目录，其中可能包括源代码文件、测试数据、编译和运行的结果等。通过查看和分析这个工作空间，你可以回顾和改进你的解题思路，也可以与其他同学交流分享经验。 总...
数据结构---栈和队列OJ习题
qq_35297945的博客
01-19 439
1 括号匹配问题 1.1 题目介绍 给定一个只包括 ‘(’，’)’，’{’，’}’，’[’，’]’ 的字符串，判断字符串是否有效。 有效字符串需满足：     左括号必须用相同类型的右括号闭合。     左括号必须以正确的顺序闭合。 注意:空字符串可被认为是有效字符串。 示例 1: 输入: “([])” 输出: true 示例 3: 输入: “(][)” 输出: false 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/valid-paren
数据结构与算法(Python版) | (7) 队列、列表OJ作业
12-21
在这篇关于“数据结构与算法(Python版) | (7) 队列、列表OJ作业”的文章中，我们将关注队列这一基本数据结构以及其在解决实际问题中的应用。 首先，我们来看有序队列的问题。有序队列要求队列中的元素按照一定的...
循环队列
星空
10-22 355
源代码： #include&lt;iostream&gt; #define m 5 using namespace std; int a[m],i=0; int front,rear; //初始化一个队列 void init(int &amp;front,int &amp;rear) { front = rear = -1; cout&lt;&lt;"front = "&lt;&lt;...
数据结构 之 循环队列
zealice的博客
09-14 332
队列符合先进先出的原则，循环队列可以持续地往队列里增加元素、减少元素。 以下为例。 MyQueue.h #ifndef MYQUEUE_H #define MYQUEUE_H #include"Customer.h" #include"MyQueue.h" #include using namespace std; template //用类模板 class MyQueue {
数据结构——循环队列
weixin_46246967的博客
04-10 186
/*******简单实现了插入，删除，长度，退出等功能********/ 详情请查询这里：https://www.itdaan.com/blog/2016/12/28/3577aeda4ed237b2c044f29c126b67c7.html
数据结构 - 循环队列
最新发布
weixin_52952392的博客
10-29 979
循环队列（Circular Queue），也被称为环形队列，是一种特殊的队列数据结构，其特点在于它的队列元素排列呈环形，队列的头部和尾部相连，形成一个闭环。这种数据结构具有一定的固定大小，一旦队列的尾部追上队列的头部，就会发生循环，即新元素会覆盖队列中最早添加的元素，从而实现了循环利用内存空间的效果。
数据结构(循环队列)
库蒂尼奥的博客
07-30 325
今天我们谈一谈循环队列，首先什么是循环队列，为什么要有循环队列了？ 首先我们需要知道对于队列的实现可以使用链表，也可以使用数组，这个我们在前面的博客中谈过了，使用链表就遵循队列的先进先出原则，尾部插入(入队)，头部删除(出队)，不用考虑扩容(堆的空间足够),并且在出队时，只要移动头部指针，释放头一个元素结点就可以了，但是对于数组去实现队列，就会造成一个问题，我们举例: void QueueOut(QueueNode *p){ assert(p != NULL); if (QueueEmpty(p)){
数据结构之循环队列
insistll的博客
10-29 442
队列：其原理就像火车的车厢进出隧道，先进的先出，后进的后出。(first in first out)代码实现如下：package com.ll.dataStruct; /** * <p>Title:MyCycleQueue </p> <p>Description: 循环队列</p> <p>Company: </p> * @author ll * @date 2017-10-29下午17:51
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值