LeetCode662.设计循环队列||4种方法实现

最新推荐文章于 2024-03-24 22:09:06 发布
最新推荐文章于 2024-03-24 22:09:06 发布
阅读量977 收藏 4
点赞数 2
文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74278159/article/details/130766514
版权

目录

题目

 思路1(链表)

代码

思路2(数组)

 代码

题目

题目要求的队列需要实现的功能有
①Creat---设置队列长度
②Front---获取队列头
③Rear---获取队列尾
④en----插入元素
⑤de---删除元素
⑥empty---判空
⑦full---判满

 思路1(链表)

🔍普通队列长度没有限制，循环队列的长度是初始化时被规定的。

❓ 请思考：普通的队列我们可以通过链表来实现，那么环状的队列能否继续通过链表实现呢？
💡答案：可以，需要将链表设计为循环链表。🔑解析：这样可以通过最后一个链表节点找到第一个链表节点。

❓请思考：怎么通过循环链表构造循环队列呢？
构造出一个循环链表，定义front指向队列头，定义back指向队列尾后一个空间。规定front==back时队列为空。

 🔨插入4个元素

 ❗注意：此时不能继续插入元素了，如果在插入元素，back接下来就和front一样，而这是我们之前定义队列为空的条件。也就是说：在前提条件front==back表示队列为空时，循环链表有5个节点，只能存储4个数据，推而广之，如果想要队列中存放k个数据，那么循环链表需要定义(k+1)个节点。

🔨删除元素：删除队列头只需要将链表头删即可。

 ❗注意：🚫头删不要将需要删除数据所在的空间释放，这样可能会导致下次插入元素时非法访问内存空间。头删只需要让front指向下一个空间即可。front和back之间的数据才是队列中的元素。

❓请思考：怎么找到队列尾？
💡解决方案：
①循环队列结构中添加一个preTail指针，指向链表尾节点的前一个结点。
②遍历整个链表，在链表尾节点的前一个节点时停止遍历。
③使用双向循环链表。

三种方案大同小异，这里不在赘述

代码

💬方案1代码

//使用链表实现循环队列
typedef struct Qnode
{
    struct Qnode* next;
    int val;
}Qnode;
typedef struct MyCircularQueue{
    Qnode* head;
    Qnode* tail;
    Qnode* preTail;
    int size;
    int capacity;
} MyCircularQueue;


MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue* q = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    q->size = 0;
    q->capacity = k;
    //创建第一个空间
    q->head = (Qnode*)malloc(sizeof(Qnode));
    q->tail = q->head;
    q->preTail = NULL;
    Qnode* cur = q->head;
    //创建k个节点
    while (k--)
    {
        cur->next = (Qnode*)malloc(sizeof(Qnode));
        cur = cur->next;
    }
    cur->next = q->head;
    return q;
}

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    //队列满了插入失败
    if (obj->tail->next == obj->head)
        return false;
   //插入数据
   obj->tail->val = value;
   obj->preTail = obj->tail;
   obj->tail = obj->tail->next;
   obj->size++;
   return true;
}

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    //队列为空删除失败
    if (obj->size == 0)
        return false;
    //链表头删(不要销free节点的空间)
    obj->head = obj->head->next;
    obj->size--;
    return true;
}

int myCircularQueueFront(MyCircularQueue* obj) {
    return obj->size == 0 ? -1 : obj->head->val;
}

int myCircularQueueRear(MyCircularQueue* obj) {
    return obj->size == 0 ? -1 : obj->preTail->val;
}

bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    return obj->size == 0;
}

bool myCircularQueueIsFull(MyCircularQueue* obj) {
    return obj->size == obj->capacity;
}

void myCircularQueueFree(MyCircularQueue* obj) {
    //需要释放k+1个节点
    int cnt = obj->capacity + 1;
    Qnode* cur = obj->head;
    while (cnt--)
    {
        Qnode* tmp = cur->next;
        free(cur);
        cur = tmp;
    }
    free(obj);
}

💬方案2代码

//使用链表实现循环队列
typedef struct Qnode
{
    struct Qnode* next;
    int val;
}Qnode;
typedef struct MyCircularQueue{
    Qnode* head;
    Qnode* tail;
    int size;
    int capacity;
} MyCircularQueue;


MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue* q = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    q->size = 0;
    q->capacity = k;
    //创建第一个空间
    q->head = (Qnode*)malloc(sizeof(Qnode));
    //tail==front，初始化为空
    q->tail = q->head;
    Qnode* cur = q->head;
    //创建k个节点
    while (k--)
    {
        cur->next = (Qnode*)malloc(sizeof(Qnode));
        cur = cur->next;
    }
    cur->next = q->head;
    return q;
}

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    //队列满了插入失败
    if (obj->size == obj->capacity)
        return false;
   //插入数据
   obj->tail->val = value;
   obj->tail = obj->tail->next;
   obj->size++;
   return true;
}

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    //队列为空删除失败
    if (obj->size == 0)
        return false;
    //链表头删(不要销free节点的空间)
    obj->head = obj->head->next;
    obj->size--;
    return true;
}

int myCircularQueueFront(MyCircularQueue* obj) {
    return obj->size == 0 ? -1 : obj->head->val;
}

int myCircularQueueRear(MyCircularQueue* obj) {
    if (obj->size == 0)
        return -1;
    //遍历链表
    Qnode* cur = obj->head;
    while (cur->next != obj->tail)
    {
        cur = cur->next;
    }
    return cur->val;
}

bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    return obj->size == 0;
}

bool myCircularQueueIsFull(MyCircularQueue* obj) {
    return obj->size == obj->capacity;
}

void myCircularQueueFree(MyCircularQueue* obj) {
    //需要释放k+1个节点
    int cnt = obj->capacity + 1;

    Qnode* cur = obj->head;
    while (cnt--)
    {
        Qnode* tmp = cur->next;
        free(cur);
        cur = tmp;
    }
    free(obj);
}

💬方shu'zu案3代码

//使用链表实现循环队列
typedef struct Qnode
{
    struct Qnode* next;
    struct Qnode* pre;
    int val;
}Qnode;
typedef struct MyCircularQueue{
    Qnode* head;
    Qnode* tail;
    int size;
    int capacity;
} MyCircularQueue;


MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue* q = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    q->size = 0;
    q->capacity = k;
    //创建第一个空间
    q->head = (Qnode*)malloc(sizeof(Qnode));
    //tail==front，初始化为空
    q->tail = q->head;
    Qnode* cur = q->head;
    //创建k个节点
    while (k--)
    {
        Qnode* newnode = (Qnode*)malloc(sizeof(Qnode));
        cur->next = newnode;
        newnode->pre = cur;
        cur = cur->next;
    }
    cur->next = q->head;
    q->head->pre = cur;
    return q;
}

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    //队列满了插入失败
    if (obj->size == obj->capacity)
        return false;
   //插入数据
   obj->tail->val = value;
   obj->tail = obj->tail->next;
   obj->size++;
   return true;
}

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    //队列为空删除失败
    if (obj->size == 0)
        return false;
    //链表头删(不要销free节点的空间)
    obj->head = obj->head->next;
    obj->size--;
    return true;
}

int myCircularQueueFront(MyCircularQueue* obj) {
    return obj->size == 0 ? -1 : obj->head->val;
}

int myCircularQueueRear(MyCircularQueue* obj) {
   return obj->size == 0 ? -1 : obj->tail->pre->val;
}

bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    return obj->size == 0;
}

bool myCircularQueueIsFull(MyCircularQueue* obj) {
    return obj->size == obj->capacity;
}

void myCircularQueueFree(MyCircularQueue* obj) {
    //需要释放k+1个节点
    int cnt = obj->capacity + 1;

    Qnode* cur = obj->head;
    while (cnt--)
    {
        Qnode* tmp = cur->next;
        free(cur);
        cur = tmp;
    }
    free(obj);
}

思路2(数组)

❓先思考：通过数组实现的环形队列有哪些成员？
🔑数组、队列头下标、队列尾下标、队列元素个数、队列最大容量。

我们规定头下标和尾下标相等时队列为空。
📚来看数组模拟循环队列示意图(队列的容量是5)：
①🔨队列为空

 ②🔨入队

 ③🔨出队

 

 ④🔨入队​​​​​​​

❗注意：从上述过程中可以观察到：在物理结构中 ，队尾可能在队头的前面也可能在队头后面。
🔺思维导图：

 代码

typedef struct {
    int* a;//a指向数组
    int front;//头下标
    int back;//尾下标
    int size;//队列元素个数
    int capacity;
} MyCircularQueue;


MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue* q = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    q->a = (int*)malloc(sizeof(int) * (k + 1));
    q->size = 0;
    q->capacity = k;
    q->front = q->back = 0;
    return q;
}

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    //队列已满
    if (obj->size == obj->capacity)
        return false;
    obj->a[obj->back] = value;
    obj->back++;
    //尾下标越界归0
    if (obj->back > obj->capacity)
    {
        obj->back = 0;
    }
    obj->size++;
    return true;
}

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    if (obj->size == 0)
        return false;
    obj->front++;
    //头下标越界归0
    if (obj->front > obj->capacity)
        obj->front = 0;
    obj->size--;
    return true;
}

int myCircularQueueFront(MyCircularQueue* obj) {
    return obj->size == 0 ? -1 :  obj->a[obj->front];
}

int myCircularQueueRear(MyCircularQueue* obj) {
    //空队列
    if (obj->size == 0)
        return -1;
    if (obj->back == 0)
    {
       return obj->a[obj->capacity];
    }
    return obj->a[obj->back - 1];
}

bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    return obj->size == 0;
}

bool myCircularQueueIsFull(MyCircularQueue* obj) {
    return obj->size == obj->capacity;
}

void myCircularQueueFree(MyCircularQueue* obj) {
    free(obj->a);
    free(obj);
}

 

syseptember
关注
  • 2
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
数据结构:循环队列的实现(leetcode622.设计循环队列)
小青菜的博客
02-22 2082
循环队列的实现
【数据结构】循环队列的实现
记录学习点滴
08-24 5039
>✨给大家推荐一款很火爆的刷题、面试求职网站✨
Leetcode刷题之设计循环队列（C语言版）
qq_64034271的博客
11-28 975
Leetcode刷题之设计循环队列（C语言版）
数据结构——循环队列详解
热门推荐
weixin_51785373的博客
10-27 1万+
队列主要有顺序队列，循环队列，双端队列，优先队列。而当中循环队列是一种线性数据结构。它也被称为“环形缓冲器”。它只允许在一端进行插入操作，即队尾（rear），而在另一端进行删除操作，即队头 (front)，其操作表现基于FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环。向队列中插入新的数据元素称为入队，新入队的元素就成为了队列的队尾元素。循环队列允许元素在队尾插入，在队头删除，同时遵循先进先出原则。由于循环队列是基于数组实现的，所以它的访问速度很快，特别是在移动元素时。
【数据结构】循环队列
不 良的博客
07-07 4263
队列又称为"先进先出（FIFO）"线性表：插入操作只能在队尾进行，删除操作只能在队首进行。而循环队列是队列的一种特殊形式，循环队列（也被称为环形队列）是一种线性数据结构，其操作表现基于先进先出原则，并且队尾被连接在队首之后以形成一个循环。循环队列固定大小，空间能够重复利用。循环队列可以用数组或者链表实现，那下面我们来分析一下哪种方式更好：当我们想使用链表实现时，假设我们想要开辟的队列长度为k = 4；front表示队头指针，rear表示队尾指针：由上图可知，当rear和front 都指向同一个位置时队列为空
bestlyg#bestlyg-leetcode#622.设计循环队列1
07-25
简介：设计你的循环队列实现。循环队列是一种线性数据结构，其操作表现基于 FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”
Java实现 LeetCode 622 设计循环队列（暴力大法）
01-20
设计你的循环队列实现。 循环队列是一种线性数据结构，其操作表现基于 FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。 循环队列的一个好处是我们可以利用这个队列之前用...
Leetcode 刷题 (11) 队列：设计循环队列
01-20
622. 设计循环队列 难度： 中等 题目分析： 看下面代码实现。参考的是裘宗燕的《数据结构与算法：Python语言描述》。此处不建议使用python内置的list的append, pop操作，使用了就违背设计循环队列的初衷：消除...
java-leetcode题解之第622题设计循环队列.zip
06-12
循环队列是一种数据结构，它在数组或链表的基础上实现了队列的特点，同时通过巧妙的设计使得“出队”和“入队”的操作更为高效，尤其在处理满队列时避免了数组或链表的重新分配。以下是对这个主题的详细解释： 1. *...
java-leetcode题解之第641题设计循环双端队列.zip
最新发布
06-12
本资源“java-leetcode题解之第641题设计循环双端队列.zip”是一个关于Java实现LeetCode第641题的解题代码包，主要涉及的数据结构是循环双端队列（Circular Doubly Linked List）。现在，我们将深入探讨这个题目及其...
单链表循环队列
Acceleration_的博客
04-28 4198
// // queue_.cpp // Cycle // // Created by ljpc on 2018/5/30. // Copyright © 2018年 ljpc. All rights reserved. // #include "queue_.h" void creatCycleQueue(CycleQueue* que) // 创建一个循环队列指针que { que->size_ = 0; que->rear = NULL; } bool is.
Leetcode循环队列（数组实现及链表实现）
qq_75270497的博客
11-01 572
讲解Leetcode循环队列的实现
实现队列（链表实现）和循环队列（数组实现）
lzqgzh的博客
08-14 326
队列的概念：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出FIFO(First In First Out) 入队列：进行插入操作的一端称为队尾（Tail/Rear） 出队列：进行删除操作的一端称为队头 （Head/Front） 实现队列也可以数组和链表的结构实现，使用链表的结构实现更优一些，因为如果使用数组的结构，出队列在数组头上出数据效率会比较低。 1.使用链表实现队列 package queue; public class My...
[leetcode]C语言用数组或链表实现循环队列
weixin_51062241的博客
11-29 1132
使用C语言数组、链表实现循环队列，leetcode设计循环队列
如何设计循环队列（两种方法）
2301_80344616的博客
03-24 1278
前面有提到过队列的知识，这次来说一下怎么设计一个循环队列一.循环队列（力扣）. - 力扣（LeetCode）. - 备战技术面试？力扣提供海量技术面试资源，帮助你高效提升编程技能,轻松拿下世界 IT 名企 Dream Offer。设计你的循环队列实现。循环队列是一种线性数据结构，其操作表现基于 FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。循环队列的一个好处是我们可以利用这个队列之前用过的空间。
循环队列的操作与实现(c语言)
lixin203171613的博客
12-08 1018
循环队列就是给定队列的范围，在原有队列的基础上，只要队列的后方满了，就从这个队列的前面开始进行插入，从而达到循环使用队列，由于循环队列本身跟平常的顺序一样，但是其设计思维像一个环，所以经常用一个环图来表示循环队列。循环队列如下图所示：[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HlbeQ7rK-1670504084833)(C:\Users\LENOVO\Desktop\屏幕截图 2022-12-08 140831.png)]
循环队列（链表、数组）
m0_65213200的博客
08-25 707
循环队列（数组、链表）
循环队列-队列的链式表示及实现
wxdn_xm的博客
09-16 353
#include<iostream> using namespace std; #define MAXQSIZE 100 //q.rear+1=q.front则队列满 typedef struct { int *base;//循环链表空间 int front;//头指针,指向首元素，直接用下标指向链表空间,因此循环队列是基于数组实现的 int rear;//尾指针，指向最后一个元...
C语言数据结构———链式队列(链表实现方式)
RaphaelCeo的博客
01-14 1万+
链式队列(链表实现方式) 有关队列相关知识请查看上一章 C语言数据结构———循环队列(静态数组实现方式) 一、链式队列 链式队列 ： 用链表形式实现的队列。链表结点为队列数据存储区，链表结点包括两部分数据存储区和指针存储区。 数据存储区 ：存放真实有效数据的区域。 指针存储区 ：存放下一个链表结点的地址。 注意： 1. 链式队列不存在队列已满的情况。在内存足够大的情况下，每次动态申请链表结...
leetcode 994.腐烂的橘子 python
09-06
你好！对于LeetCode上的问题994.腐烂的橘子，你可以使用Python来解决。下面是一个示例代码： ```python from collections import deque def orangesRotting(grid): # 记录网格的行数和列数 row, col = len(grid), len(grid[0]) # 定义四个方向：上、下、左、右 directions = [(-1, 0), (1, 0), (0, -1), (0, 1)] # 使用队列来保存腐烂的橘子的位置 queue = deque() # 记录新鲜橘子的数量 fresh_count = 0 # 遍历整个网格，初始化队列和新鲜橘子的数量 for i in range(row): for j in range(col): if grid[i][j] == 2: # 腐烂的橘子 queue.append((i, j)) elif grid[i][j] == 1: # 新鲜橘子 fresh_count += 1 # 如果新鲜橘子的数量为0，直接返回0 if fresh_count == 0: return 0 # 初始化分钟数 minutes = 0 # 开始进行BFS，直到队列为空 while queue: # 记录当前分钟数下，队列中的元素数量 size = len(queue) # 遍历当前分钟数下的所有腐烂的橘子 for _ in range(size): x, y = queue.popleft() # 遍历四个方向 for dx, dy in directions: nx, ny = x + dx, y + dy # 判断新位置是否在网格内，并且是新鲜橘子 if 0 <= nx < row and 0 <= ny < col and grid[nx][ny] == 1: # 将新鲜橘子变为腐烂状态 grid[nx][ny] = 2 # 将新鲜橘子的位置加入队列 queue.append((nx, ny)) # 新鲜橘子的数量减1 fresh_count -= 1 # 如果当前分钟数下，没有新鲜橘子了，结束循环 if fresh_count == 0: break # 每遍历完一层，分钟数加1 minutes += 1 # 如果最后还有新鲜橘子，返回-1，否则返回分钟数 return -1 if fresh_count > 0 else minutes ``` 你可以将给定的网格作为参数传递给`orangesRotting`函数来测试它。请注意，该代码使用了BFS算法来遍历橘子，并计算腐烂的分钟数。希望能对你有所帮助！如果有任何疑问，请随时问我。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值