L36.【LeetCode笔记】循环队列(链表解法)

已于 2025-05-08 17:07:23 修改
阅读量879 收藏 15
点赞数 25
CC 4.0 BY-SA版权
分类专栏： LeetCode题解 # 队列 文章标签： leetcode 笔记 链表 c语言 算法
于 2025-03-15 09:57:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_85828611/article/details/146122522

目录

1.题目

2.分析

3.单向链表未优化的代码

4.优化方案1:使用双向循环链表

知识回顾

代码

提交结果

5.优化方案2:使用rear_prev记录rear指向节点的前一个节点

提交结果

6.一道笔试题

分析

%maxsize极为重要,没有的话会在某些特殊情况下判断出错

1.题目

https://leetcode.cn/problems/design-circular-queue/description/

设计你的循环队列实现。 循环队列是一种线性数据结构，其操作表现基于 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 的范围内；
  • 请不要使用内置的队列库。

2.分析

之前在L33.【LeetCode题解】循环队列(数组解法)文章中提到过数组的解法,链表解决的思想也在那篇文章中,本文写写链表的代码

3.单向链表未优化的代码

typedef struct listnode
{
    struct listnode* next;
    int val;
}node;

typedef struct 
{
    node* head;
    node* front;
    node* rear;
    int k;
} MyCircularQueue;


MyCircularQueue* myCircularQueueCreate(int k) 
{
    MyCircularQueue* queue=(MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    queue->k=k;
    node* cur=NULL;
    //初始化（k+1）个节点
    int count=k+1;
    while(count--)
    {
        node* newnode=(node*)malloc(sizeof(node));
        if (cur==NULL)
        {
            queue->head=cur=newnode;
        }
        else
        {
            cur->next=newnode;
            cur=newnode;
        }
    }
    cur->next=queue->head;
    queue->front=queue->rear=queue->head;
    return queue;
}
bool myCircularQueueIsFull(MyCircularQueue* obj);
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) 
{
    if (myCircularQueueIsFull(obj))
        return false;
    obj->rear->val=value;
    obj->rear=obj->rear->next;
    return true;
}
bool myCircularQueueIsEmpty(MyCircularQueue* obj);
bool myCircularQueueDeQueue(MyCircularQueue* obj) 
{
    if (myCircularQueueIsEmpty(obj))
        return false;
    obj->front=obj->front->next;
    return true;
}

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

int myCircularQueueRear(MyCircularQueue* obj) 
{
    if (myCircularQueueIsEmpty(obj))
        return -1;
    node* cur=obj->rear;
    while(cur->next!=obj->rear)
    {
        cur=cur->next;
    }
    return cur->val;
}

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

bool myCircularQueueIsFull(MyCircularQueue* obj) 
{
    return obj->rear->next==obj->front;
}

void myCircularQueueFree(MyCircularQueue* obj) 
{
    int count=obj->k+1;
    while(count--)
    {
        node* tmp=obj->head->next;
        free(obj->head);
        obj->head=tmp;
    }
    free(obj);
}

运行结果:

在L33.【LeetCode题解】循环队列(数组解法)文章中只讲了单向循环链表的解法,但此方法是有缺陷的,原因:找尾时间复杂度为O(N),在上方代码的myCircularQueueRear函数中,rear指向尾节点的下一个节点,由于是单向链表,则需要采用循环来找尾节点

下面给出两种优化方案:

4.优化方案1:使用双向循环链表

知识回顾

复习双向循环链表:

96.【C语言】数据结构之双向链表的初始化,尾插,打印和尾删

97.【C语言】数据结构之双向链表的头插,头删,查找,中间插入,中间删除和销毁函数

代码

注:相比单向循环链表,改动的地方在listnode的成员变量、myCircularQueueCreate函数和myCircularQueueRear函数

typedef struct listnode
{
    struct listnode* next;
    struct listnode* prev;
    int val;
}node;

typedef struct 
{
    node* head;
    node* front;
    node* rear;
    int k;
} MyCircularQueue;


MyCircularQueue* myCircularQueueCreate(int k) 
{
    MyCircularQueue* queue=(MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    queue->head=queue->front=queue->rear=NULL;
    queue->k=k;
    int count=k+1;
    node* cur=NULL;
    while(count--)//创建k+1个节点
    {
        node* newnode=(node*)malloc(sizeof(node));
        
        if (queue->head==NULL)
        {
            queue->head=cur=newnode;
            queue->front=queue->rear=queue->head;
            queue->head->next=queue->head->prev;
            queue->head->prev=queue->head->next;
        }
        else
        {
            cur->next=newnode;
            newnode->prev=cur;
            newnode->next=queue->head;
            queue->head->prev=newnode;
            cur=cur->next;
        }
    }
    return queue;
}

bool myCircularQueueIsFull(MyCircularQueue* obj);
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) 
{
    if (myCircularQueueIsFull(obj))
        return false;
    obj->rear->val=value;
    obj->rear=obj->rear->next;
    return true;   
}

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

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

int myCircularQueueRear(MyCircularQueue* obj) 
{
    if (myCircularQueueIsEmpty(obj))
        return -1;
    return obj->rear->prev->val;
    
}

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

bool myCircularQueueIsFull(MyCircularQueue* obj) 
{
    return obj->rear->next==obj->front;
}

void myCircularQueueFree(MyCircularQueue* obj) 
{
    int count=obj->k+1;
    while(count--)
    {
        node* tmp=obj->head->next;
        free(obj->head);
        obj->head=tmp;
    }
    free(obj);
}

提交结果

5.优化方案2:使用rear_prev记录rear指向节点的前一个节点

注:相比单向循环链表,改动的地方在MyCircularQueue匿名结构体的成员变量、myCircularQueueCreate函数、myCircularQueueRear函数和myCircularQueueEnQueue函数

typedef struct listnode
{
    struct listnode* next;
    int val;
}node;
 
typedef struct 
{
    node* head;
    node* front;
    node* rear;
    node* rear_prev;
    int k;
} MyCircularQueue;
 
 
MyCircularQueue* myCircularQueueCreate(int k) 
{
    MyCircularQueue* queue=(MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    queue->k=k;
    node* cur=NULL;
    //初始化（k+1）个节点
    int count=k+1;
    while(count--)
    {
        node* newnode=(node*)malloc(sizeof(node));
        if (cur==NULL)
        {
            queue->head=cur=newnode;
        }
        else
        {
            cur->next=newnode;
            cur=newnode;
        }
    }
    cur->next=queue->head;
    queue->rear_prev=cur;//设置rear_prev在rear前
    queue->front=queue->rear=queue->head;
    return queue;
}
bool myCircularQueueIsFull(MyCircularQueue* obj);
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) 
{
    if (myCircularQueueIsFull(obj))
        return false;
    obj->rear->val=value;
    obj->rear=obj->rear->next;
    obj->rear_prev=obj->rear_prev->next;
    return true;
}
bool myCircularQueueIsEmpty(MyCircularQueue* obj);
bool myCircularQueueDeQueue(MyCircularQueue* obj) 
{
    if (myCircularQueueIsEmpty(obj))
        return false;
    obj->front=obj->front->next;
    return true;
}
 
int myCircularQueueFront(MyCircularQueue* obj) 
{
    if (myCircularQueueIsEmpty(obj))
        return -1;
    return obj->front->val;    
}
 
int myCircularQueueRear(MyCircularQueue* obj) 
{
    if (myCircularQueueIsEmpty(obj))
        return -1;
    return obj->rear_prev->val;
}
 
bool myCircularQueueIsEmpty(MyCircularQueue* obj) 
{
    return obj->front==obj->rear;
}
 
bool myCircularQueueIsFull(MyCircularQueue* obj) 
{
    return obj->rear->next==obj->front;
}
 
void myCircularQueueFree(MyCircularQueue* obj) 
{
    int count=obj->k+1;
    while(count--)
    {
        node* tmp=obj->head->next;
        free(obj->head);
        obj->head=tmp;
    }
    free(obj);
}

提交结果

6.一道笔试题

来源:【2023】奇安信春招C++方向试卷1

分析

正确答案:B

读题发现是用数组实现的

发现四个选项都有%maxsize,解释maxsize:循环队列的总空间,例如当maxsize==5时,最多只能存4个元素,要留下一个空间来判断空和满

%maxsize极为重要,没有的话会在某些特殊情况下判断出错

k==4时,maxsize==5,

1.画出初始状态:

2.入队4个元素后:

3.出队一个,再入队一个:

4.出队一个,再入队一个:

第1步:ring.front==0,ring.end==0

第2步:ring.front==0,ring.end==4

第3步:ring.front==1,ring.end==0

第4步:ring.front==2,ring.end==1

经验证:(ring.end+1)%maxsize == ring.front是正确的,如果为ring.end+1 == ring.front,则在第1、2步时会出问题(注意:第1~4步包含了front和end所有可能的取值,考虑特殊情况:都为0或者其中一个为0)

链表实现循环队列
北风七级的专栏
04-09 933
struct Node { elem e; Node* pNext; }; //循环队列 class MyQueue { public: MyQueue():pQueueHead(NULL),pQueueRear(NULL),queueSize(10),queueSizeInc(10){}; ~MyQueue(){destroyMyQueue();}; bool initMyQueue
Leetcode：662.Design Circular Queue 设计循环队列
Coding
09-18 1104
Design Circular Queue 设计循环队列 设计你的循环队列实现。 循环队列是一种线性数据结构，其操作表现基于 FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。 循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里，一旦一个队列满了，我们就不能插入下一个元素，即使在队列前面仍有空间。但是使用循环队列，我们能使用这些空间去存...
用链表 设计 循环队列
qq_24472227的博客
01-10 774
用链表设计循环队列
循环队列模版（链表实现）
lovecontry
07-18 252
用链表实现循环队列，也是写几个常用功能，其实和循环列表大同小异 ，就是它的一个特殊形式而已。 文件"myqueue.h" #include<iostream> using namespace std; template<class T> class My_queue; template<class T> class Node { private: ...
链表循环队列程序
05-23
链表循环队列简单的C语言程序供初学者参考，希望有用。
HSK标准教程6下 课件 L36pptx.pptx
03-22
中国古代书院的教育理念与HSK标准教程6下的第三十六课 在研究汉语和中国文化时，不能不提及中国古代书院。书院不仅是中国传统教育的发源地，更是儒家思想和文化传承的重要场所。HSK标准教程6下的第三十六课，就将...
L36h 10.1.A.1.350 基带
10-09
L36h 10.1.A.1.350 国行基带
L36 某西安博物馆营销策略分析 全文 - 副本.zip
09-14
L36 某西安博物馆营销策略分析 全文 - 副本.zip
L365L363L36L313L310L220L130喷头强力清洗软件
01-27
标题中的“L365L363L36L313L310L220L130喷头强力清洗软件”表明这是一个针对特定型号喷头的清洁工具，主要用于打印机或喷墨设备的维护。这些型号可能是打印机喷头的序列号或者型号标识，比如L365、L363、L36、L313、...
sony l36h一键root
06-28
sony l36h一键root
基于链表、数组实现队列、循环队列
刘琦的专栏
09-22 3730
队列是一种先进先出的数据结构，它和栈的性质正好相反，但是两者却经常结合在一起实现一些特殊的操作。 1.队列的接口 public interface QueueADT { //入队 public void enqueue(Object element); //出队 public Object dequeue(); //返回队首元素 public Object first(); //
循环队列（链表、数组）
m0_65213200的博客
08-25 814
循环队列（数组、链表）
LeetCode 622——设计循环队列
weixin_34090643的博客
10-15 608
1. 题目 设计你的循环队列实现。 循环队列是一种线性数据结构，其操作表现基于 FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。 循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里，一旦一个队列满了，我们就不能插入下一个元素，即使在队列前面仍有空间。但是使用循环队列，我们能使...
用循环链表表示队列
qq_58299006的博客
10-24 6740
假设以带头结点的循环链表表示列队，并且只设一个指针指向队尾元素结点（注意不设头指针），试编写相应的置空队、判队空、入队和出队等算法。 该算法使用循环链表表示列队。 在算法中只设一个指向队尾元素的指针rear，在进行置空队，判队空等操作之前先将队列初始化； 置空队则是将队尾指针指向头结点； 入队则是在队尾插入元素，即在尾结点处插入元素，先申请一个新结点，再将新结点初始化并链入队列最后将尾指针移至新结点； 出队是先判断队列是否为空，不为空则继续接下来的出队操作。 该算法设计了个函数： 函数init
数据结构-单链表模拟实现循环队列（c语言实现）
weixin_59799963的博客
10-16 1912
1.
[leetcode]C语言用数组或链表实现循环队列
weixin_51062241的博客
11-29 1235
使用C语言数组、链表实现循环队列，leetcode设计循环队列
用循环链表实现队列
Gofor.
04-11 587
AC代码： #include <iostream> #define Status int #define QElemType int using namespace std; // 链队结点数据结构 typedef struct QNode { QElemType data; // 数据域 struct QNode *next; // 指针域 }QNode, *QueuePtr; struct QNode *rear; // 队尾指针 //******************
[记录] 数据结构----队列的实现(循环队列 链表队列)
uttues_l的博客
04-29 460
/* 1、在队列中，允许插入的一端叫队尾（rear），允许删除的一端称为队头(front)。 2、队头指针始终指向队列头元素(先出队，后++) 队尾指针始终指向队列尾元素的下一个位置(先++，后进队) 3、少用一个元素的空间 front = rear，循环队列空 (rear+1) % MAXQSIZE = front，循环队列满（rear始终指向空...
数据结构.链表实现环形队列
qq_41056269的博客
10-10 489
Queue.h #include<stdio.h> #include<stdlib.h> #include<assert.h> typedef int DataType; typedef struct QueueNode { DataType _data; struct QueueNode* _next; }QueueNode; typedef struct Q...
L36h手机开机动画教程与压缩文件下载
在了解“香蕉开机动画，l36h可用”这一知识点前，首先要明确开机动画的概念。开机动画是指在设备启动过程中，系统启动界面显示的一段动画序列。这个动画不仅提升了用户体验，还可以展示设备品牌或者系统的特色。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

zhangcoder

赠人玫瑰手有余香,感谢支持~

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

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

打赏作者

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

抵扣说明：

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

余额充值