C语言：设计循环队列

最新推荐文章于 2024-07-09 17:14:48 发布
最新推荐文章于 2024-07-09 17:14:48 发布
阅读量908 收藏 35
点赞数 40
文章标签： c语言 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Another_Shi/article/details/138918883
版权

目录

前言：

顺序表代码实现循环队列：

   代码思路： 

        1、创建一个顺序表

        2、 创建一个循环队列

        3、判断

        4、插入

        5、删除

        6、取数据

        7、销毁循环队列

链表代码实现循环队列：

     代码思路：

        1、创建节点和链表结构

        2、创建一个循环队列

        3、判断

        4、插入

        5、删除

        6、取数据

         7、销毁循环队列

前言：

        本篇博客是写完LeetCode_662.设计循环队列之后有感而发，于是写下了一些思路和总结。

本题用了两种方法来解答——顺序表和链表。

顺序表代码实现循环队列：

//创建顺序表
typedef struct 
{
    int* a;  //顺序表
    int head;//顺序表的头
    int tail;//顺序表的尾
    int k;   //能存放数据的个数
} MyCircularQueue;
//判断循环队列是否为空
bool myCircularQueueIsEmpty(MyCircularQueue* obj) 
{
    //当尾的位置与头的位置相同时，说明循环队列已经空了                    
    return obj->head == obj->tail;
}
//判断循环队列是否为满
bool myCircularQueueIsFull(MyCircularQueue* obj) 
{
    //当尾的位置与头的位置相差一的时候，说明循环队列已经满了
    return (obj->tail + 1) % (obj->k + 1) == obj->head;
}
//创建循环队列
MyCircularQueue* myCircularQueueCreate(int k) 
{
    MyCircularQueue* newnode = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    //初始化顺序表
    //创建比要存放的数据个数多一个，便于以后的判断
    newnode->a = (int*)malloc(sizeof(int) * (k + 1));
    newnode->head = 0;
    newnode->tail = 0;
    newnode->k = k;

    return newnode;
}

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) 
{
    //当循环队列满的时候不能插入
    if(myCircularQueueIsFull(obj))
        return false;
    else
    {
        //当插入一个数据的时候，尾向后移动一位
        obj->a[obj->tail++] = value;
        //确保可以循环
        obj->tail %= obj->k + 1;
        return true;
    }
}
//删除循环队列的数据
bool myCircularQueueDeQueue(MyCircularQueue* obj) 
{
    //当循环队列满的时候不能插入
    if(myCircularQueueIsEmpty(obj))
        return false;
    else
    {
        //当删除一个数据的时候，头向后移动一位
        obj->head++;
        //确保可以循环
        obj->head %= obj->k + 1;
        return true;
    }
}
//取循环队列的头的数据
int myCircularQueueFront(MyCircularQueue* obj) 
{
    //当循环队列不为空的时候，取头的数据
    if(myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    else
    {
        return obj->a[obj->head];
    }
}
//取循环队列的尾的数据
int myCircularQueueRear(MyCircularQueue* obj) 
{
    //当循环队列不为空的时候，取尾的数据
    if(myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    else
    {
        //原来的式子 obj->a[(obj->tail - 1 + obj->k + 1) % (obj->k + 1)];
        return obj->a[(obj->tail + obj->k) % (obj->k + 1)];
    }
}
//销毁循环队列
void myCircularQueueFree(MyCircularQueue* obj) 
{
    free(obj->a);
    free(obj);
}

   代码思路： 

        我们要以顺序表来设计一个循环队列。首先，创建一个顺序表，其中的head代表在数组中的头，tail代表尾，k代表可以插入的数据个数。每插入一个数据，尾的位置向后移一位，当尾的位置下一位是头的位置的时候，循环队列就满了。每删除一个数据，头的位置向后移一位，当头的位置和尾的位置一样的时候，循环队列就空了。

        1、创建一个顺序表

        顺序表的结构如下：

//创建顺序表
typedef struct 
{
    int* a;  //顺序表
    int head;//顺序表的头
    int tail;//顺序表的尾
    int k;   //能存放数据的个数
} MyCircularQueue;

        2、 创建一个循环队列

        注意：需要malloc一个变量用来返回，不能直接创建一个循环队列，因为不在堆上，当出了作用域空间会被回收。且创建数组的时候要多一块空间便于我们判断循环队列是否满了。

//创建循环队列
MyCircularQueue* myCircularQueueCreate(int k) 
{
    MyCircularQueue* newnode = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    //初始化顺序表
    //创建比要存放的数据个数多一个，便于以后的判断
    newnode->a = (int*)malloc(sizeof(int) * (k + 1));
    newnode->head = 0;
    newnode->tail = 0;
    newnode->k = k;

    return newnode;
}

        3、判断

        当尾的位置与头的位置相同时，说明循环队列已经空了。

        当尾的后一位就是头的位置时，说明循环队列已经满了。但会出现这种情况，tail的下一位会越界，所以用tail+1 %（k +1） == head ，当它们相等的时候，队列就满了。

//判断循环队列是否为空
bool myCircularQueueIsEmpty(MyCircularQueue* obj) 
{
    //当尾的位置与头的位置相同时，说明循环队列已经空了                    
    return obj->head == obj->tail;
}
//判断循环队列是否为满
bool myCircularQueueIsFull(MyCircularQueue* obj) 
{
    //当尾的位置与头的位置相差一的时候，说明循环队列已经满了
    return (obj->tail + 1) % (obj->k + 1) == obj->head;
}

        4、插入

        首先，我们要判断循环队列是否满了，如果满了就返回false，反之，插入数据。当插入数据的时候，tail++。

        注意：每次tail++完之后，记得要确保tail没有越界，如果越界了，就表明要返回到0的位置。

所以有tail %= k + 1。

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) 
{
    //当循环队列满的时候不能插入
    if(myCircularQueueIsFull(obj))
        return false;
    else
    {
        //当插入一个数据的时候，尾向后移动一位
        obj->a[obj->tail++] = value;
        //确保可以循环
        obj->tail %= obj->k + 1;
        return true;
    }
}

        5、删除

        首先，我们要判断循环队列是否为空了，如果空了就返回false，反之，删除数据。当插入数据的时候，head++。

        注意：每次head++完之后，记得要确保head没有越界，如果越界了，就表明要返回到0的位置。所以有head%= k + 1。

//删除循环队列的数据
bool myCircularQueueDeQueue(MyCircularQueue* obj) 
{
    //当循环队列满的时候不能插入
    if(myCircularQueueIsEmpty(obj))
        return false;
    else
    {
        //当删除一个数据的时候，头向后移动一位
        obj->head++;
        //确保可以循环
        obj->head %= obj->k + 1;
        return true;
    }
}

        6、取数据

        当循环队列不为空的时候，取头的数据。

        当循环队列不为空的时候，取尾的数据。注意：还有这种特殊的情况——tail的前一位在数组的末尾，就需要用(tail - 1 + k + 1) % (k + 1)

//取循环队列的头的数据
int myCircularQueueFront(MyCircularQueue* obj) 
{
    //当循环队列不为空的时候，取头的数据
    if(myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    else
    {
        return obj->a[obj->head];
    }
}
//取循环队列的尾的数据
int myCircularQueueRear(MyCircularQueue* obj) 
{
    //当循环队列不为空的时候，取尾的数据
    if(myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    else
    {
        //原来的式子 obj->a[(obj->tail - 1 + obj->k + 1) % (obj->k + 1)];
        return obj->a[(obj->tail + obj->k) % (obj->k + 1)];
    }
}

        7、销毁循环队列

        注意：不要只释放了循环队列，顺序也得释放，不然会导致内存泄漏。

//销毁循环队列
void myCircularQueueFree(MyCircularQueue* obj) 
{
    free(obj->a);
    free(obj);
}

 以上就是用顺序表来实现一个循环队列的代码。

链表代码实现循环队列：

struct List
{
    int _val;
    struct List* next;
};

typedef struct {
    struct List* head;
    struct List* tail;
    struct List* tail_prev;
} MyCircularQueue;

struct List* BuyNewNode()
{
    struct List* new = (struct List*)malloc(sizeof(struct List));
    new->_val = 0;
    new->next = NULL;
    return new;
}

MyCircularQueue* myCircularQueueCreate(int k) 
{
    MyCircularQueue* obj = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));

    obj->tail_prev = NULL;
    obj->head = obj->tail = BuyNewNode();

    for(int i = 0; i < k; i++)
    {
        struct List* new = BuyNewNode();

        obj->tail_prev = obj->tail;
        obj->tail = new;
        obj->tail_prev->next = obj->tail;
    }

    obj->tail->next = obj->head;

    obj->tail_prev = NULL;
    obj->tail = obj->head;

    return obj;
}

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

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

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) 
{
    if(myCircularQueueIsFull(obj))
        return false;
    
    obj->tail->_val = value;
    obj->tail_prev = obj->tail;

    obj->tail = obj->tail->next;
    return true;
}

bool myCircularQueueDeQueue(MyCircularQueue* obj)
{
    if(myCircularQueueIsEmpty(obj))
        return false;

    obj->head = obj->head->next;
    return true;

}

int myCircularQueueFront(MyCircularQueue* obj) 
{
    if(!myCircularQueueIsEmpty(obj))
    {
    return obj->head->_val;
    }
    else
    {
        return -1;
    }
}

int myCircularQueueRear(MyCircularQueue* obj) 
{
    if(!myCircularQueueIsEmpty(obj))
    {
        return obj->tail_prev->_val;
    }
    else
    {
        return -1;
    }
}

void myCircularQueueFree(MyCircularQueue* obj) 
{
    struct List* cur = obj->head;
    obj->tail->next = NULL;

    while(cur)
    {
        struct List* next = cur->next;
        free(cur);
        cur = next;
    }

    free(obj);
}

     代码思路：

        我们首先要自定义一个链表结构体节点，接着自定义一个结构体来存放结构体节点的头、尾和尾的前一个节点，以便于后面获取头和尾节点的数据；记得要我们自己来将链表连成一个环（如下图所示）；当你插入一个数据的时候，尾指针要向后移动一位；当你要删除数据的时候，头指针向后移动一位；最后，当头指针和尾指针在同一位置的时候说明此时循环队列为空，当尾指针的下一位是头指针的时候说明此时循环队列为满。

        1、创建节点和链表结构

        head是用来记录循环队列队首的数据，tail_prev是用来记录循环队列队尾的数据，tail是与head相比较来判断循环队列是否为空(满)。

//创建节点
struct List
{
    int _val;//存放数据
    struct List* next;
};

typedef struct {
    struct List* head;//创建头指针来获取头节点的数据
    struct List* tail;//创建尾指针的前一位指针来获取尾节点的数据
    struct List* tail_prev;//创建尾指针来确定循环队列是否为空(满)
} MyCircularQueue;

        2、创建一个循环队列

        要创建一个循环队列，首先我们要malloc一个结构体自变量来接收它；先创建一个节点，随后开始创建一个比实际存储个数多一的链表，然后将链表首位相连，最后重新初始化尾指针和尾指针的前一位指针。

//创建一个节点
struct List* BuyNewNode()
{
    struct List* new = (struct List*)malloc(sizeof(struct List));
    new->_val = 0;
    new->next = NULL;
    return new;
}
//创建一个循环队列
MyCircularQueue* myCircularQueueCreate(int k) 
{
    //创建一个结构体自变量，使其成为循环队列
    MyCircularQueue* obj = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    //初始化链表
    obj->tail_prev = NULL;
    obj->head = obj->tail = BuyNewNode();
    //创建一个比要存放数据个数多一的链表
    for(int i = 0; i < k; i++)
    {
        struct List* new = BuyNewNode();

        obj->tail_prev = obj->tail;
        obj->tail = new;
        obj->tail_prev->next = obj->tail;
    }
    //将链表首尾相连
    obj->tail->next = obj->head;
    //将尾指针和尾指针的前一位指针重新初始化
    obj->tail_prev = NULL;
    obj->tail = obj->head;

    return obj;
}

        3、判断

        用链表实现循环队列就比较简单了。当头尾指针相等的时候，循环队列为空，当尾指针的下一位是头指针的时候，循环队列为满。

//当头尾指针相等的时候，循环队列为空
bool myCircularQueueIsEmpty(MyCircularQueue* obj) 
{
    return obj->head == obj->tail;
}
//当尾指针的下一位是头指针的时候，循环队列为满
bool myCircularQueueIsFull(MyCircularQueue* obj) 
{
    return obj->tail->next == obj->head;
}

        4、插入

        首先我们要判断循环队列是否为满，如果没有满就插入数据。成功插入数据到尾指针的成员上，首先尾指针的前一位指针要指向当前尾指针的地址，然后尾指针后移动一位。（顺序不能错）

//插入数据到循环队列
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) 
{
    //当循环队列满的时候，返回false
    if(myCircularQueueIsFull(obj))
        return false;
    //成功插入数据到尾指针的成员上，首先尾指针的前一位指针要指向当前尾指针的地址
    obj->tail->_val = value;
    obj->tail_prev = obj->tail;
    //然后尾指针后移动一位
    obj->tail = obj->tail->next;
    return true;
}

        5、删除

        首先判断一下循环队列是否为空，如果不为空，直接将头节点向后移动一位就可以了。

//删除数据到循环队列
bool myCircularQueueDeQueue(MyCircularQueue* obj)
{
    if(myCircularQueueIsEmpty(obj))
        return false;
    //直接将头节点向后移动一位
    obj->head = obj->head->next;
    return true;
}

        6、取数据

        因为我们有head指针和tail_prev指针，所以我们可以很方便的取到队首和队尾的数据。

//取队首的数据
int myCircularQueueFront(MyCircularQueue* obj) 
{
    if(!myCircularQueueIsEmpty(obj))
    {
    return obj->head->_val;
    }
    else
    {
        return -1;
    }
}
//取队尾的数据
int myCircularQueueRear(MyCircularQueue* obj) 
{
    if(!myCircularQueueIsEmpty(obj))
    {
        return obj->tail_prev->_val;
    }
    else
    {
        return -1;
    }
}

         7、销毁循环队列

        我们首先要销毁循环链表，然后再销毁循环队列。

//销毁循环队列
void myCircularQueueFree(MyCircularQueue* obj) 
{
    //先销毁链表
    struct List* cur = obj->head;
    obj->tail->next = NULL;

    while(cur)
    {
        struct List* next = cur->next;
        free(cur);
        cur = next;
    }
    //再销毁销毁队列
    free(obj);
}

以上就是用链表实现一个循环队列的代码和思路。

（完） 

Another_Shi
关注
  • 40
    点赞
  • 踩
  • 35
    收藏
    觉得还不错? 一键收藏
  • 7
    评论
C语言实现:设计循环队列(数组实现)
Wzs040810的博客
08-07 226
C语言实现:设计循环队列（数组版）
用C语言数组设计循环队列
i_Crave的博客
11-11 1726
解释： 设计你的循环队列实现。 循环队列是一种线性数据结构，其操作表现基于 FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。 循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里，一旦一个队列满了，我们就不能插入下一个元素，即使在队列前面仍有空间。但是使用循环队列，我们能使用这些空间去存储新的值。 来源：力扣（LeetCode） 链接：622. 设计循环队列 - 力扣（LeetCode） (leetcode-cn.com) 著作权归领扣网络
数据结构：设计循环队列（C语言代码实现）详细·解读代码
qq_56870066的博客
02-06 955
设计循环队列
设计循环队列（C语言）
Butayarou的博客
02-24 961
【题目描述】 设计你的循环队列实现。 循环队列是一种线性数据结构，其操作表现基于 FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。 循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里，一旦一个队列满了，我们就不能插入下一个元素，即使在队列前面仍有空间。但是使用循环队列，我们能使用这些空间去存储新的值。 Your MyCircularQueue struct will be instantiated and called as such: My
c语言：循环队列的实现
在路上
03-28 1001
#include #include #include #define QUEUE_MAX_SIZE 100 using namespace std; typedef struct Sqqueue { int *data; int front; int rear; }Sqqueue; //函数声明 void Error(char *s);
C语言设计循环队列
a7897989的博客
08-16 1376
一种简单思路，用C语言实现循环队列
C语言版：循环队列的建立和基本操作
m0_53318344的博客
06-30 1660
来自C语言版数据结构：介绍关于循环队列的建立，入队，出队，求队长， 取队头元素操作。 文章目录循环队列一、采用CLion编译二、队列的基本操作1.建立和初始化2.入队3.出队4.取对头元素和队列长度代码实现 循环队列 队列的一种顺序存储方式， 为什么叫循环队列 ？ 第一：防止 "假溢出"， 这是由对的操作造成 "对尾进， 对头出"。 很可能在其他位置还有空间， 但是却报错了（越界）具体措施： 书上是利用模运行（%）去解决的， 呈现出环状时候，就不会出现 "假溢出" 的情况 提示：以下是本篇文章正文内
C语言实现循环队列
weixin_62029250的博客
12-02 1475
循环队列五分钟教会
c语言循环队列的销毁,C语言循环队列
weixin_39651488的博客
05-22 1430
参考自维基百科：含测试代码，详细注释：#include #include #include /*循环队列 C语言实现*2011-04-28*liliming123@sina.com*/#ifndef QElementType#define QElementType int#endif#ifndef MAX_SIZE#define MAX_SIZE 500#endiftypedef struct{Q...
xqueue：基于C语言实现的循环队列缓冲区
04-09
在实现循环队列时，C语言提供了直接操作内存的手段，如指针操作，使得创建高效的循环队列数据结构成为可能。 根据提供的链接，`xqueue`是一个用C语言实现的循环队列缓冲区。这个库可能包含以下关键组成部分： 1. *...
详解数据结构C语言实现之循环队列
09-01
在C语言中，实现循环队列通常涉及定义一个结构体来存储队列的属性，包括存储元素的数组、队头指针`front`、队尾指针`rear`以及队列的最大容量`maxsize`。 1. 循环队列基础： - 参数：循环队列需要两个关键参数，即...
C语言循环队列的表示与实现实例详解
09-04
循环队列是计算机科学中数据结构的一种，它在C语言中被广泛用于处理有序的数据序列，尤其是当需要遵循先进先出（FIFO）原则时。循环队列的主要优点在于它可以有效地处理“溢出”问题，即使在固定大小的存储空间内也...
使用C语言来解决循环队列问题的方法
09-03
在C语言中实现循环队列，通常需要定义一个结构体来存储队列的状态，包括队头、队尾指针以及队列中的元素数组。 以下是一个使用C语言实现循环队列的基本步骤： 1. **定义队列结构体**： 首先，我们需要定义一个...
算法的时间复杂度（C语言）
m0_73634434的博客
07-05 793
1.时间复杂度的定义在计算机科学中，算法的时间复杂度是一个函数，它定量描述了算法的运行时间。一个算法所花费的时间与其中语句的执行次数成正比列，例1：计算Func1中++count执行的次数当我们的N取无穷大时2 * N + 10这两个项对结果的影响已经不大了可以忽略不计，所以说只需要取来表示它的时间复杂度就可以了所以这段代码2.大O的渐进表示法通过上面一个例子我们可以发现大O渐进表示法去掉了那些对结果影响不大的项，简洁明了的表示出了执行次数我们来计算几道代码的时间复杂度。
数据结构 Java DS——链表部分经典题目 (1)
cjejwe的博客
07-09 271
笔者计划在暑假啃完JavaDS,Mysql的内容当然也会继续更这次给读者们分享的是链表的几个比较典型的题目,关于如何手搓一个链表,笔者还在筹划中,毕竟链表的种类也有那么多,但是在下面的题目中,只有单向链表。
(5) 深入探索Python-Pandas库的核心数据结构：Series详解
架构筑梦的Cherry Yang的博客
07-06 914
# 1. Series 简介 pandas数据结构中的Series是一个一维数组对象，能够保存任何数据类型（整数、字符串、浮点数、Python对象等），并有一个与之关联的标签序列，这些标签被称为“索引”（index）。索引与数据是一一对应的，通过索引可以快速获取、更新或删除数据。Series在pandas数据处理中起着至关重要的作用，是构建更复杂数据结构（如DataFrame）的基础。 以下是关于pandas Series的详细解释： * **定义**：Series类似于一维数组或列表，但它有一个显式的
Redis教程(二十三)：Redis的底层数据结构
最新发布
十三月的博客
07-09 37
Redis是一种高性能的key-value数据库，广泛用于缓存、消息队列、应用程序会话管理等领域。它之所以能提供高效的数据操作性能，很大程度上归功于其底层使用了多种优化过的数据结构来存储数据。
C语言实现高效循环队列
05-16
C语言中实现高效循环队列需要注意以下几点： 1. 循环队列的头尾指针需要特殊处理，当头指针和尾指针相遇时，需要进行特殊处理。 2. 循环队列的大小需要预先确定，一旦确定就不能改变。 3. 循环队列中最多只能容纳 (队列大小 - 1) 个元素，因为需要一个空位来判断队列是否为空或已满。 4. 循环队列的入队和出队操作都需要特殊处理，具体可以根据头尾指针的位置关系和队列大小进行判断。 以下是一个基于数组实现的高效循环队列的示例代码： ```c #define MAX_SIZE 100 typedef struct { int data[MAX_SIZE]; int head; int tail; } MyCircularQueue; MyCircularQueue* myCircularQueueCreate(int k) { MyCircularQueue *queue = (MyCircularQueue *)malloc(sizeof(MyCircularQueue)); queue->head = 0; queue->tail = 0; return queue; } bool myCircularQueueIsEmpty(MyCircularQueue* obj) { return (obj->head == obj->tail); } bool myCircularQueueIsFull(MyCircularQueue* obj) { return ((obj->tail + 1) % MAX_SIZE == obj->head); } bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) { if (myCircularQueueIsFull(obj)) { return false; } obj->data[obj->tail] = value; obj->tail = (obj->tail + 1) % MAX_SIZE; return true; } bool myCircularQueueDeQueue(MyCircularQueue* obj) { if (myCircularQueueIsEmpty(obj)) { return false; } obj->head = (obj->head + 1) % MAX_SIZE; return true; } int myCircularQueueFront(MyCircularQueue* obj) { if (myCircularQueueIsEmpty(obj)) { return -1; } return obj->data[obj->head]; } int myCircularQueueRear(MyCircularQueue* obj) { if (myCircularQueueIsEmpty(obj)) { return -1; } return obj->data[(obj->tail - 1 + MAX_SIZE) % MAX_SIZE]; } void myCircularQueueFree(MyCircularQueue* obj) { free(obj); } ```

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值