循环队列的实现

已于 2024-05-14 12:02:22 修改
阅读量470 收藏 15
点赞数 17
分类专栏： 数据结构 文章标签： c语言 算法 数据结构
于 2024-05-13 23:50:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/paradiso989/article/details/138805674
版权

目录

一、什么是循环队列

二、链表实现循环队列

2.1 单链表实现

2.2 双链表实现

三、数组实现循环队列

3.1 思路分析

3.1.1 如何判空判满

3.1.2 如何处理回环问题

3.1.3 如何取出尾部元素

3.2 开辟空间法实现

3.3 创建size变量实现

一、什么是循环队列

        循环队列是一种数据结构，它与普通队列类似，但是在循环队列中，当队列满时，新的元素可以覆盖队列前面的元素。循环队列通常使用数组来实现，在队列尾部插入元素，在队列头部删除元素，并且可以循环利用数组空间，使得队列的操作更加高效。循环队列可以解决普通队列需要频繁的元素搬移的问题，提高了队列的操作效率。

        LeetCode原题链接：. 622.- 力扣（LeetCode）

​

二、链表实现循环队列

2.1 单链表实现

        通过增加了一个limit变量实现，仅仅实现了逻辑上的循环队列，没有实现物理结构上的循环，该方法即使可以通过LeetCode判题，但不是推荐解法。

typedef struct {
    struct ListNode *head;
    struct ListNode *tail;
    int limit;    //限制容量
    int size;     //实际容量
} MyCircularQueue;

MyCircularQueue* myCircularQueueCreate(int k) 
{
    MyCircularQueue *obj = (MyCircularQueue *)malloc(sizeof(MyCircularQueue));
    obj->limit = k;
    obj->size = 0;
    obj->head = obj->tail = NULL;
    return obj;
}
//入队
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) 
{
    if (obj->size >= obj->capacity) 
    {
        return false;
    }
    struct ListNode *node = (struct ListNode *)malloc(sizeof(struct ListNode));
    if(node==NULL)
    {
        perror("malloc");
        exit(1);
    }
    node->val = value;
    node->next = NULL;
    //头插
    if (!obj->head) 
    {
        obj->head = obj->tail = node;
    } 
    else 
    {
        obj->tail->next = node;
        obj->tail = node;
    }
    obj->size++;
    return true;
}
//出队
bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    if (obj->size == 0) {
        return false;
    }
    struct ListNode *node = obj->head;
    obj->head = obj->head->next;  
    obj->size--;
    free(node);
    return true;
}
//返回队首元素
int myCircularQueueFront(MyCircularQueue* obj) {
    if (obj->size == 0) {
        return -1;
    }
    return obj->head->val;
}
//返回队尾元素
int myCircularQueueRear(MyCircularQueue* obj) {
    if (obj->size == 0) {
        return -1;
    }
    return obj->tail->val;
}
//判空
bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    return obj->size == 0;
}
//判满
bool myCircularQueueIsFull(MyCircularQueue* obj) {
    return obj->size == obj->limit;
}
//销毁
void myCircularQueueFree(MyCircularQueue* obj) {
    for (struct ListNode *temp = obj->head; temp;) {
        struct ListNode *newnode = temp;
        temp = temp->next;
        free(newnode);
    }
    free(obj);
}

2.2 双链表实现

        使用定长无头双向链表，实现循环队列

typedef struct ListNode
{
    int data;
    struct ListNode* next; // 指针保存下⼀个节点的地址
    struct ListNode* prev; // 指针保存前⼀个节点的地址
}ListNode;

typedef struct {
    ListNode* phead;   //指向队首元素
    ListNode* ptail;   //指向队尾元素的下一个位置
    int k;
    int size;
} MyCircularQueue;

//重复开辟空间操作单独封装
ListNode* ListBuyNode(int x)
{
    ListNode* newnode = (ListNode*)malloc(sizeof(ListNode));
    if (newnode == NULL)
    {
        perror("malloc");
        exit(1);
    }
    newnode->data = x;
    newnode->next = newnode;
    newnode->prev = newnode;

    return newnode;
}
//尾插
void ListPushBack(ListNode* head)
{
    assert(head);
    ListNode* newnode = ListBuyNode(0);
    newnode->prev = head->prev;
    newnode->next = head;

    head->prev->next = newnode;
    head->prev = newnode;
}
//创建物理上的循环队列
MyCircularQueue* myCircularQueueCreate(int k)
{
    MyCircularQueue* obj = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    if (obj == NULL)
    {
        perror("malloc");
        exit(1);
    }
    obj->phead = obj->ptail = ListBuyNode(0);
    obj->size = 0;
    obj->k = k;
    while (k-1)
    {
        ListPushBack(obj->phead);
        k--;
    }
    obj->ptail = obj->phead;
    return obj;
}
//判空
bool myCircularQueueIsEmpty(MyCircularQueue* obj) 
{
    assert(obj);
    return obj->size == 0;
}
//判满
bool myCircularQueueIsFull(MyCircularQueue* obj) 
{
    assert(obj);
    return obj->size == obj->k;
}
//入队
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) 
{
    assert(obj);
    if (myCircularQueueIsFull(obj))
    {
        return false;
    }
    obj->ptail->data = value;
    obj->ptail = obj->ptail->next;
    obj->size++;
    return true;
}
//出队
bool myCircularQueueDeQueue(MyCircularQueue* obj) 
{
    assert(obj);
    if (myCircularQueueIsEmpty(obj))
    {
        return false;
    }
    obj->phead = obj->phead->next;
    obj->size--;
    return true;
}
//返回队首元素
int myCircularQueueFront(MyCircularQueue* obj) 
{
    assert(obj);
    if (myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    return obj->phead->data;
}
//返回队尾元素
int myCircularQueueRear(MyCircularQueue* obj) 
{
    assert(obj);
    if (myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    return obj->ptail->prev->data;
}
//销毁队列
void myCircularQueueFree(MyCircularQueue* obj) 
{
    assert(obj);
    ListNode* temp = NULL;
    while (obj->size)
    {
        temp = obj->phead;
        obj->phead = obj->phead->next;
        free(temp);
        temp = NULL;
        obj->size--;
    }
    obj->phead = obj->ptail = NULL;
    free(obj);
}

三、数组实现循环队列

3.1 思路分析

3.1.1 如何判空判满

        看到这个问题可能最直接的思路就是，当头指针与尾指针重合时，链表为满。但是通过图示不难发现，空和满的最后的结果都是一样的：头指针等于尾指针。

        对于这个问题有以下两种解决方式：

  • 在结构体中设置size变量：最直接且最有效的方式
  • 额外开辟一个空间：将空和满的情况区分开，tail+1 = head，但是仍然涉及到了回环问题，见下文解释。

3.1.2 如何处理回环问题

tail指向最后一个元素，指向下一个元素时如何将tail的值变为从0开始？

  • 若设计的空间等于有效空间个数：采用取模的做法。因为：任何小于被操作数的取模都等于它自身，等于被操作数的取模等于0。只需取空间的大小，便完美解决了该问题。
  • 若设计的空间比有效空间的个数多一个：可以判断tail所指的元素是否为0，为0则tail置为0

同理：head也可以这样处理

3.1.3 如何取出尾部元素

        如果是正常的情况（物理结构上头指针在尾指针的前面），无需考虑这个问题；主要考虑特殊情况（物理结构上头指针在尾指针的后面）。本质上讨论的依然是回环的问题。

  • 既可以采用if判断tail是否为0
  • 也可以采用取模的办法

3.2 开辟空间法实现

typedef struct {
    int head;   //指向首元素
    int tail;   //指向尾元素的下一个位置
    int k;
    int* a;
} MyCircularQueue;

MyCircularQueue* myCircularQueueCreate(int k) 
{
    MyCircularQueue* obj = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    if (obj == NULL)
    {
        perror("malloc");
        exit(1);
    }
    obj->a = (int*)malloc((k + 1) * sizeof(int));
    if (obj->a == NULL)
    {
        perror("malloc");
        exit(1);
    }
    obj->k = k;
    obj->head = 0;
    obj->tail = 0;
    return obj;
}

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

bool myCircularQueueIsFull(MyCircularQueue* obj) {
    return (obj->tail + 1) % (obj->k + 1) == obj->head;
}

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    if (myCircularQueueIsFull(obj)) 
    {
        return false;
    }
    obj->a[obj->tail] = value;
    obj->tail++;
    //判断是否绕环
    obj->tail %= (obj->k + 1);
    return true;
}

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    if (myCircularQueueIsEmpty(obj)) 
    {
        return false;
    }
    obj->head++;
    //判断是否绕环
    obj->head %= (obj->k + 1);
    return true;
}

int myCircularQueueFront(MyCircularQueue* obj) {
    if (myCircularQueueIsEmpty(obj)) 
    {
        return -1;
    }
    return obj->a[obj->head];
}

int myCircularQueueRear(MyCircularQueue* obj) {
    if (myCircularQueueIsEmpty(obj)) 
    {
        return -1;
    }
    return obj->a[(obj->tail - 1 + obj->k + 1) % (obj->k + 1)];
}

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

3.3 创建size变量实现

typedef struct {
    int head;   //指向首元素
    int tail;   //指向尾元素的下一个位置
    int k;
    int* a;
    int size;
} MyCircularQueue;

MyCircularQueue* myCircularQueueCreate(int k)
{
    MyCircularQueue* obj = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    if (obj == NULL)
    {
        perror("malloc");
        exit(1);
    }
    obj->a = (int*)malloc(k * sizeof(int));
    if (obj->a == NULL)
    {
        perror("malloc");
        exit(1);
    }
    obj->k = k;
    obj->head = 0;
    obj->tail = 0;
    obj->size = 0;
    return obj;
}

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

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

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    if (myCircularQueueIsFull(obj))
    {
        return false;
    }
    obj->a[obj->tail] = value;
    obj->tail++;
    //判断是否绕环
    obj->tail %= (obj->k);
    return true;
}

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    if (myCircularQueueIsEmpty(obj))
    {
        return false;
    }
    obj->head++;
    //判断是否绕环
    obj->head %= (obj->k);
    return true;
}

int myCircularQueueFront(MyCircularQueue* obj) {
    if (myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    return obj->a[obj->head];
}

int myCircularQueueRear(MyCircularQueue* obj) {
    if (myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    return obj->a[(obj->tail + obj->k) % (obj->k)];
}

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

都市隸人
关注
  • 17
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
C++循环队列实现模型
09-04
C++循环队列实现模型是数据结构中一种高效且实用的方法，它在处理大量数据时具有较高的效率。循环队列的原理是利用数组的“首尾相连”特性，形成一个循环，使得队列的入队（enqueue）和出队（dequeue）操作能够在...
51单片机的FIFO（先入先出）循环队列实现
07-25
本文给大家分享了51单片机的FIFO（先入先出）循环队列实现的源代码。
c语言之循环队列实现二叉树的层次遍历
qq_41277195的博客
08-09 2029
二叉树的层次遍历思想就是从根结点开始，从左至右从上层往下层挨个遍历。用一个数组实现的循环队列来实现就比较简单。根结点进入队列，然后出队，根节的左孩子不为空的话左孩子进队，后孩子不为空的话右孩子进队。然后循环如此直到循环队列空为止。 代码如下： #include<stdio.h> #include<stdlib.h> #define tree_size 6//定义二叉树的结点...
c语言 循环队列实现舞伴匹配
LM306的博客
07-06 3324
c语言实现舞伴配对： 要求： 1．在舞会上男女各自排成一队，舞会开始时每一次从男队和女队的对头各出一人配成舞伴， 直到某队为空，如果两队初始人数不等，则较长的那一队中未配对者等待下一轮舞曲。 某轮舞毕，则舞者按该轮出序，重入各自队列。 2．假设初始男女人数分别为 11 人和 8 人，舞会三轮，试模拟解决上述舞伴配对问题， 3．要求从屏幕输出每一轮舞伴配对名单，如果在该轮有没有配上对的，能够从屏幕显示下 一轮第一个出场的未配对者的姓名。...
Java中循环队列实现_Java循环队列的实现方法
weixin_31459297的博客
02-23 2057
Java循环队列的实现方法时间：2017-09-13来源：华清远见JAVA学院生活中有很多队列的影子，比如打饭排队，买火车票排队问题等，可以说与时间相关的问题，一般都会涉及到队列问题。那么Java如何实现循环队列呢?今天华清Java学院小编就以Java如何用数组实现循环队列为例，和大家分享一下Java循环队列的实现方法。Java循环队列的实现代码如下：1、队列的类class CirQue...
入门数据结构，c语言实现循环队列实现（详细篇）。
A2202333的博客
11-08 4987
队列中的一个分支循环队列，运用了一些技巧降低了其时间复杂度与空间复杂度，学会循环队列可以帮助更好的学习后面复杂的结构（如：树，二叉树，图等）。
循环队列实现
u012864854的博客
08-10 1万+
       假设是长度为5的数组，初始状态，空队列如所示，front与 rear指针均指向下标为0的位置。然后入队a1、a2、a3、a4, front指针依然指向下标为0位置，而rear指针指向下标为4的位置。         出队a1、a2，则front指针指向下标为2的位置，rear不变，如下图所示，再入队a5，此时front指针不变，rear指针移动到数组之外 ，造成假溢出的现象。 ...
基于C语言的循环队列实现(包含完整代码)
weixin_43369883的博客
05-18 1135
循环队列不同于非循环队列和链表,其操作不需要定义next指针,只是单纯的定义一个固定的结构体变量,此结构体中的数组变量已经可以包含全部的已定义的队列长度.(如果采用循环链表来实现队列也可行,但队列会成为可变长的)
C语言实现循环队列
热门推荐
qq_43629857的博客
06-24 1万+
详解循环队列的巧妙之处
数据结构与算法：循环队列实现代码（C语言）
weixin_46711800的博客
08-22 1745
编译环境：VC++6.0 实现操作：循环队列初始化、判队空、入队、出队、获取队头元素以及输出队列元素 实现代码： #include<stdio.h> #include<stdlib.h> #define MAXSIZE 50 #define bool int typedef struct { int data[MAXSIZE]; int front; int rear; }SqQueue; void InitQueue(SqQueue *Q) //初始化队列 { Q
单片机实现环形队列_51单片机的FIFO(先入先出)循环队列实现
weixin_35275781的博客
12-28 1211
原标题：51单片机的FIFO(先入先出)循环队列实现typedef unsigned char uint8; /* defined for unsigned 8-bits integer variable 无符号8位整型变量 */typedef signed char int8; /* defined for signed 8-bits integer variable 有符号8位整型变量 */t...
CircularQueue循环队列实现
11-03
在这个实现中，我们主要探讨如何通过C++或者类似的编程语言来构建一个高效的循环队列，并将其封装成一个易于使用的库。 首先，我们需要理解循环队列的基本概念。在传统的线性队列中，如果队列的尾部达到了数组的...
C++实现循环队列
08-25
C++实现循环队列 C++实现循环队列是指使用C++语言来实现循环队列数据结构。循环队列是一种特殊的队列结构，能够循环使用队列中的元素，从而提高了队列的使用效率。 在C++中，实现循环队列可以使用模板类来实现。...
IO多路复用-select的使用详解【C语言】
qq_42037383的博客
07-21 898
IO多路转接也称为IO多路复用，它是一种网络通信的手段（机制），通过这种方式可以同时监测多个文件描述符并且这个过程是阻塞的，一旦检测到有文件描述符就绪（ 可以读数据或者可以写数据）程序的阻塞就会被解除，之后就可以基于这些（一个或多个）就绪的文件描述符进行通信了。通过这种方式在单线程/进程的场景下也可以在服务器端实现并发。常见的IO多路转接方式有：select、poll、epoll。
C语言——字符串中sizeof和strlen的辨析
weixin_45720999的博客
07-19 393
在C语言中，sizeof 和 strlen 函数在处理字符串时有明显不同的作用和结果。使用不当很容易出现错误......
【C语言】 约瑟夫环，循环链表实现
最新发布
2301_77133426的博客
07-22 101
1、循环链表实现约瑟夫环，每次经过特定步数删除一个元素
c语言（7.22）
fhgfyrsg的博客
07-22 380
在7，23，79，81，103，127，131，147中查找数据*/核心思路：就是从数组的0索引开始，依次往后查找，如果找到了，就会返回数据对应的索引。如果没有找到，就会返回-1。//不是用mid和num进行比较。//2.定义变量表示要查找的数据。//2，定义一个要查的数据。/*需求：数组的二分查找。//mid应该放在循环里面。/* 需求：数组的基本查找。
C语言控制语句：分支、循环和转向
2302_81410974的博客
07-21 890
1. 分支语句：if语句、switch语句； 2. 循环语句：for语句、while语句、do-while语句； 3. 转向语句：break语句、continue语句、return语句、goto语句。
循环队列实现凯撒加密
11-05
循环队列和凯撒加密并没有直接的联系，循环队列是一种数据结构，而凯撒加密是一种加密算法。但是可以通过循环队列来实现凯撒加密的过程中的移位操作。具体实现方法如下： 1. 将明文转换为ASCII码，然后将ASCII码与密钥进行移位操作，得到密文的ASCII码。 2. 将密文的ASCII码转换为字符，得到密文。 在移位操作中，可以使用循环队列来实现。将密钥作为队列的长度，将明文的ASCII码依次入队，然后出队并进行移位操作，得到密文的ASCII码。具体实现方法如下： 1. 将明文转换为ASCII码，然后将ASCII码依次入队。 2. 将队列的头部元素出队，并将其加上密钥进行移位操作，得到密文的ASCII码。 3. 将密文的ASCII码转换为字符，得到密文。 4. 重复2-3步骤，直到队列为空。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值