设计循环队列

已于 2023-11-29 19:10:52 修改
阅读量1.6k 收藏 29
点赞数 30
分类专栏： 初阶数据结构 文章标签： 数据结构 算法 c语言 开发语言
于 2023-11-29 12:35:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74841364/article/details/134652462
版权

目录

设计循环队列

🙂【1】数组循环队列

思路分析

❓1

❓2

❓3

易错总结

创建MyCircularQueue

初始化myCircularQueueCreate

为空否myCircularQueueIsEmpty

为满否myCircularQueueIsFull

插入元素myCircularQueueEnQueue

删除元素myCircularQueueDeQueue

获取首元素myCircularQueueFront

获取尾元素myCircularQueueRear

释放空间myCircularQueueFree

🆗【1】总代码

🙂【2】链表循环队列 

思路分析

❓

易错总结 

创建MyCircularQueue

初始化myCircularQueueCreate

为空否myCircularQueueIsEmpty

为满否myCircularQueueIsFull

插入元素myCircularQueueEnQueue

删除元素myCircularQueueDeQueue

获取首元素myCircularQueueFront

获取尾元素myCircularQueueRear

释放空间myCircularQueueFree

🆗【2】总代码

另外扩展了解一下，实际中我们有时还会使用一种队列叫【循环队列】。如操作系统讲解【生产者消费者模型】时可以就会使用循环队列。环形队列可以使用【数组】实现，也可以使用循环【链表】实现。我们今天来实现一下。

设计循环队列

设计你的循环队列实现。 循环队列是一种线性数据结构，其操作表现基于 FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。

循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里，一旦一个队列满了，我们就不能插入下一个元素，即使在队列前面仍有空间。但是使用循环队列，我们能使用这些空间去存储新的值。

你的实现应该支持如下操作：

  • MyCircularQueue(k): 构造器，设置队列长度为 k 。
  • Front: 从队首获取元素。如果队列为空，返回 -1 。
  • Rear: 获取队尾元素。如果队列为空，返回 -1 。
  • enQueue(value): 向循环队列插入一个元素。如果成功插入则返回真。
  • deQueue(): 从循环队列中删除一个元素。如果成功删除则返回真。
  • isEmpty(): 检查循环队列是否为空。
  • isFull(): 检查循环队列是否已满。

 

🙂【1】数组循环队列

 

这个【数组循环队列】在逻辑上是如上图所示，但是在物理上，不是循环的。所以特别注意：关于数组循环的这个点，我们必须手动控制。 

思路分析

❓1

空和放一个元素怎么区分？

  • 方法1：back初始化为0，指向队尾元素的下一个位置。
  • 方法2：back初始化为-1，指向队尾元素。 
  • 特别提醒！：用方法1比较好控制

 

❓2

空和满怎样去区分（用方法1区分空和一个元素）？

  • 方法1：设置size。
  • 方法2：malloc多一个空间，不放置元素。（k+1)
  • 以上两者方法都可以。

❓3

怎么处理数组物理上不循环（改成逻辑上循环）？

  • (back+1)%(k+1) = fron
  • obj->back %= obj->k+1
  • return obj->a[(obj->back-1+obj->k+1)%(obj->k+1)]

这里是以判空和满的来讲解，其他的插入和取尾元素是同理的！！ 

易错总结

  • 临时变量出了函数就销毁了，必须malloc
  • A%B（A>B对A来说是没有任何影响，A<=B对A来说模去多余的B）---用来处理数组回绕地方
  • 操作符优先级 所以最好都加上括号
  • 处理的表达式的左边不能为计算式（❌obj->front+1%=obj->k+1;）
  • 判空和满直接下标运算即可，不用用数组（为什么不能用数组❓）
  • 释放空间先释放数组空间，在释放myCircularQueue

创建MyCircularQueue

//用数组实现+多开辟一个空间不放元素
typedef struct {
    int*a;
    int front;
    int back;//数组下标
    int k;//循环队列的最多放置数据
} MyCircularQueue;

初始化myCircularQueueCreate

MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue*obj=(MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    int*tmp=(int*)malloc(sizeof(int)*(k+1));//多开辟一个空间
    obj->a=tmp;
    obj->front=0;
    obj->back=0;//指向最后一个元素的下一个
    obj->k=k;
    return obj;
}

为空否myCircularQueueIsEmpty

//判断循环队列是否为空
bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    return obj->front == obj->back;//==0 
}

为满否myCircularQueueIsFull

//判断是否为满
bool myCircularQueueIsFull(MyCircularQueue* obj) {
    return (obj->back+1) % (obj->k+1) == obj->front;//back+1=front
    //操作符优先级问题
}

插入元素myCircularQueueEnQueue

 考虑下这个特殊情况！

//插入元素
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    if(myCircularQueueIsFull(obj))//true 满了
    {
        return false;
    }
        obj->a[obj->back] = value;
        obj->back++;
        obj->back %= obj->k+1;//处理
        //obj->front+1%=obj->k+1;//处理左边不能为计算表达式
       return true;
}

删除元素myCircularQueueDeQueue

  考虑下这个特殊情况！

//删除元素
bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
    {
        return false;
    }
    else
    {
        obj->front++;
        obj->front%=obj->k+1;//处理
        return true;
    }
}

获取首元素myCircularQueueFront

//获取首元素
int myCircularQueueFront(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    else
    return obj->a[obj->front];
}

获取尾元素myCircularQueueRear

  考虑下这个特殊情况！

//获取尾元素
int myCircularQueueRear(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    else
    //return obj->a[(obj->back-1+obj->k+1)%(obj->k+1)];
    return obj->a[(obj->back+obj->k)%(obj->k+1)];
}

释放空间myCircularQueueFree

//释放空间
void myCircularQueueFree(MyCircularQueue* obj) {
    free(obj->a);
    free(obj);
    obj=NULL;
}

🆗【1】总代码

//用数组实现+多开辟一个空间不放元素
typedef struct {
    int*a;
    int front;
    int back;//数组下标
    int k;//循环队列的最多放置数据
} MyCircularQueue;


MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue*obj=(MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    int*tmp=(int*)malloc(sizeof(int)*(k+1));//多开辟一个空间
    obj->a=tmp;
    obj->front=0;
    obj->back=0;//指向最后一个元素的下一个
    obj->k=k;
    return obj;
}
//判断循环队列是否为空
bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    return obj->front == obj->back;//==0 
}

//判断是否为满
bool myCircularQueueIsFull(MyCircularQueue* obj) {
    return (obj->back+1) % (obj->k+1) == obj->front;//back+1=front
    //操作符优先级问题
}

//插入元素
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    if(myCircularQueueIsFull(obj))//true 满了
    {
        return false;
    }
        obj->a[obj->back] = value;
        obj->back++;
        obj->back %= obj->k+1;//处理
        //obj->front+1%=obj->k+1;//处理左边不能为计算表达式
       return true;
}

//删除元素
bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
    {
        return false;
    }
    else
    {
        obj->front++;
        obj->front%=obj->k+1;//处理
        return true;
    }
}

//获取首元素
int myCircularQueueFront(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    else
    return obj->a[obj->front];
}

//获取尾元素
int myCircularQueueRear(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    else
    //return obj->a[(obj->back-1+obj->k+1)%(obj->k+1)];
    return obj->a[(obj->back+obj->k)%(obj->k+1)];
}

//释放空间
void myCircularQueueFree(MyCircularQueue* obj) {
    free(obj->a);
    free(obj);
    obj=NULL;
}

🙂【2】链表循环队列 

链表很简单对于处理循环的问题，只要实现单项循环链表即可。这里的难点就是：（1）创建单项循环链表。（2）找到back的前一个元素

思路分析

关于判【空/一个元素】& 判【空/满】都是和上面数组是一样的。这里不过多阐述。

❓

怎么去找到back的前一个元素？

其实这个问题在我们前面博文实现链表也详细讲解，相信大家可以轻松掌握！！

        Node*prev=obj->front;
        while(prev->next != obj->back)
        {
            prev=prev->next;
        }

易错总结 

  • 初始化一定要把back置回开头
  • 找back前一个元素：要么用三个指针，要么遍历一遍链表。
  • 释放空间不能遍历去释放，会造成野指针。
  • 释放空间先把循环链表改变成单向链表，才能循环遍历释放。 

创建MyCircularQueue

typedef struct Node
{
    int val;
    struct Node*next;
}Node;//节点

typedef struct {
    Node*front;
    Node*back;    
    int size;//计算放入队列的元素个数
} MyCircularQueue;//循环队列

初始化myCircularQueueCreate

MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue*obj=(MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    obj->front=NULL;
    obj->back=NULL;
    while(k--)
    {
            Node*newnode=(Node*)malloc(sizeof(Node));
            if(obj->front == NULL)
            {
                obj->front=obj->back=newnode;
                obj->front->val=0;
            }
            else
            {
                obj->back->next=newnode;
                obj->back=newnode;
                obj->back->val=0;
            }
    }
    //循环
    obj->back->next=obj->front;
    //back
    obj->back=obj->front;
    //
    obj->size=0;
    return obj;
}

为空否myCircularQueueIsEmpty

//判断循环队列是否为空
bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    if(obj->size == 0 && obj->front == obj->back)
    return true;
    else
    return false;
}

为满否myCircularQueueIsFull

//判断是否为满
bool myCircularQueueIsFull(MyCircularQueue* obj) {
    if(obj->size != 0 && obj->front == obj->back)
    return true;
    else
    return false;
}

插入元素myCircularQueueEnQueue

//插入元素
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    if(myCircularQueueIsFull(obj))//true 满了
    {
        return false;
    }
    else
    {
        obj->back->val=value;
        obj->back=obj->back->next;
        obj->size++;
        return true;
    }
}

删除元素myCircularQueueDeQueue

//删除元素
bool myCircularQueueDeQueue(MyCircularQueue* obj)
{
    if(myCircularQueueIsEmpty(obj))
    {
        return false;
    }
    else
    {
        obj->front=obj->front->next;//❌易错
        obj->size--;
        return true;
    }
}

获取首元素myCircularQueueFront

//获取首元素
int myCircularQueueFront(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    return obj->front->val;
}

获取尾元素myCircularQueueRear

//获取尾元素
int myCircularQueueRear(MyCircularQueue* obj) 
{
    if(myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    //❌易错
    else
    {
        Node*prev=obj->front;
        while(prev->next != obj->back)
        {
            prev=prev->next;
        }
        return prev->val;
    }
}

释放空间myCircularQueueFree

//释放空间
//❌易错
void myCircularQueueFree(MyCircularQueue* obj) {
    Node*prev=obj->front;
    while(prev->next != obj->front)
    {
        prev=prev->next;
    }
    //prev是最后一个
    prev->next=NULL;
    //
    while(obj->front->next != NULL)
    {
        Node*tmp=obj->front;
        obj->front=obj->front->next;
        free(tmp);
        tmp=NULL;
    }
    free(obj->front);
    obj->front=NULL;
    free(obj);
    obj=NULL;
}

🆗【2】总代码

typedef struct Node
{
    int val;
    struct Node*next;
}Node;//节点

typedef struct {
    Node*front;
    Node*back;    
    int size;//计算放入队列的元素个数
} MyCircularQueue;//循环队列


MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue*obj=(MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    obj->front=NULL;
    obj->back=NULL;
    while(k--)
    {
            Node*newnode=(Node*)malloc(sizeof(Node));
            if(obj->front == NULL)
            {
                obj->front=obj->back=newnode;
                obj->front->val=0;
            }
            else
            {
                obj->back->next=newnode;
                obj->back=newnode;
                obj->back->val=0;
            }
    }
    //循环
    obj->back->next=obj->front;
    //back
    obj->back=obj->front;
    //
    obj->size=0;
    return obj;
}


//判断循环队列是否为空
bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    if(obj->size == 0 && obj->front == obj->back)
    return true;
    else
    return false;
}

//判断是否为满
bool myCircularQueueIsFull(MyCircularQueue* obj) {
    if(obj->size != 0 && obj->front == obj->back)
    return true;
    else
    return false;
}

//插入元素
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    if(myCircularQueueIsFull(obj))//true 满了
    {
        return false;
    }
    else
    {
        obj->back->val=value;
        obj->back=obj->back->next;
        obj->size++;
        return true;
    }
}

//删除元素
bool myCircularQueueDeQueue(MyCircularQueue* obj)
{
    if(myCircularQueueIsEmpty(obj))
    {
        return false;
    }
    else
    {
        obj->front=obj->front->next;
        obj->size--;
        return true;
    }
}

//获取首元素
int myCircularQueueFront(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    return obj->front->val;
}

//获取尾元素
int myCircularQueueRear(MyCircularQueue* obj) 
{
    if(myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    else
    {
        Node*prev=obj->front;
        while(prev->next != obj->back)
        {
            prev=prev->next;
        }
        return prev->val;
    }
}

//释放空间
void myCircularQueueFree(MyCircularQueue* obj) {
    Node*prev=obj->front;
    while(prev->next != obj->front)
    {
        prev=prev->next;
    }
    //prev是最后一个
    prev->next=NULL;
    //
    while(obj->front->next != NULL)
    {
        Node*tmp=obj->front;
        obj->front=obj->front->next;
        free(tmp);
        tmp=NULL;
    }
    free(obj->front);
    obj->front=NULL;
    free(obj);
    obj=NULL;
}

 还有数据结构的【栈】和操作系统的【栈】是不一样的。数据结构的【栈】是一种线性表。操作系统的【栈】是内存的区域，会发生栈溢出和内存泄露的问题（递归程序/返回条件有问题），但是数据结构【栈】不会。

✔✔✔✔✔最后，感谢大家的阅读，若有错误和不足，欢迎指正！

唐唐思
关注
  • 30
    点赞
  • 踩
  • 29
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
设计循环队列详解
zhaocx111222333的博客
02-02 852
循环队列 设计你的循环队列实现。 循环队列是一种线性数据结构，其操作表现基于 FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。 循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里，一旦一个队列满了，我们就不能插入下一个元素，即使在队列前面仍有空间。但是使用循环队列，我们能使用这些空间去存储新的值。 来源：力扣（LeetCode） 首先我们看一下循环队列的逻辑: 空队列: 图示: 即头尾节点在一个位置时,认为这个循环队列是空的. 满队列
Leetcode 刷题 (11) 队列：设计循环队列
01-20
622. 设计循环队列 难度： 中等 题目分析： 看下面代码实现。参考的是裘宗燕的《数据结构与算法：Python语言描述》。此处不建议使用python内置的list的append, pop操作，使用了就违背设计循环队列的初衷：消除...
【数据结构与算法】设计循环队列
Welcome home | Jian Liao 's blog
03-24 2697
🚩前面我们用队列实现了一个栈用栈实现了一个队列，相信大家随随便便轻松拿捏，而本章将带大家上点难度，我们来设计一个循环队列。🚩对于循环队列，重点就在一个“ 循环 ”，意思也就是该队列首尾相连形成一个环，但其本质还是不变，队列先进先出的性质依旧存在，只不过环的大小有限定（限定放多少数据就只能放多少数据）。🚩那么我们如何来设计这样的一个环，使它既能够像队列一样，又可以体现循环的性质？下面就带大家探讨一波。💝设计一个循环队列还是有些复杂的呢，不过看过本文章，相信大家也可以轻松拿捏。❤️‍🔥。
设计循环队列（LeetCode：622.设计循环队列）
qq_52777887的博客
03-16 1537
简单的接口调用实现循环队列！快来看看吧！
C语言设计循环队列
a7897989的博客
08-16 1378
一种简单思路，用C语言实现循环队列
【622. 设计循环队列】
Sugar_wolf的博客
08-02 1326
为了区别这两种情况，假设队列使用的数组有capacity个存储空间，则此时规定循环队列最多只能有capacity−1个队列元素，当循环队列中只剩下一个空存储单元时，则表示队列已满。根据以上可知，队列判空的条件是front=rear，而队列判满的条件是front=(rear+1)modcapacity。在一个普通队列里，一旦一个队列满了，我们就不能插入下一个元素，即使在队列前面仍有空间。」，我们可以通过一个数组进行模拟，通过操作数组的索引构建一个虚拟的首尾相连的环。...
用链表 设计 循环队列
qq_24472227的博客
01-10 588
用链表设计循环队列
C++ 设计循环队列
giturtle's blog
04-05 2117
目录例题描述解题思路代码实现 例题描述 设计你的循环队列实现。 循环队列是一种线性数据结构，其操作表现基于 FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。 循环队列的一个好处是：可以利用这个队列之前用过的空间。 在一个普通队列里，一旦一个队列满了，我们就不能插入下一个元素，即使在队列前面仍有空间。但是使用循环队列，我们能使用这些空间去存储新的值。 ...
数据结构—设计循环队列C语言实现
weixin_56438185的博客
04-09 2129
LeetCode题目链接：设计循环队列 题目描述： 思路： 1、因为队列是循环的，所以可以用循环链表实现，让链表尾指向链表头即可，但是会有一个问题就是，插入数据的时候，尾插找队列尾的时候不方便，记录队列尾的指针永远指向的都是队列尾的下一个位置（下面会说原因），就需要用循环来找尾 2、可以用数组来实现，数组在内存中是连续的空间，可以直接用两个数组的下标来控制队列的实现，数组实现的弊端就是在循环的时候数组边界需要特殊考虑，但是可以多加个判断条件来判断边界条件即可，相对于用链表实现更优，所以循环.
力扣 -- 设计循环队列（题解）
qq_45326605的博客
04-24 1646
此题需要实现一个循环队列，那么在此之前我们得知道队列的概念和结构 队列：只允许在一端插入，另一端删除操作的特殊线性表，具有先进先出后进后出的特性 出队列：删除的一端叫队头 入队列：插入的一端叫队尾 知道了队列的概念和结构就能开始做此题了。 题目链接 题目描述： 思路：首先先找到，队列是空的条件和队列是满的条件，找到这两个条件就很容易的做出来了，队列为空的条件我给的是当队头和队尾相等的时候说明，这个队列为空。队列满的条件这个队列和队尾的下一个相等的时候就是满的，看到这里细心的朋友可能已经看出来了，这样
设计循环双端队列
12-21
设计循环双端队列 题目 设计实现双端队列。 请不要使用内置的双端队列库。 链接：https://leetcode-cn.com/problems/design-circular-deque/ 思路 题目要求不使用内置的双端队列库，那么可以考虑使用双指针，即队首...
Java实现 LeetCode 622 设计循环队列（暴力大法）
01-20
622. 设计循环队列 设计你的循环队列实现。 循环队列是一种线性数据结构，其操作表现基于 FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。 循环队列的一个好处是我们可以...
java-leetcode题解之第622题设计循环队列.zip
06-12
在本压缩包中，我们关注的是Java编程语言与LeetCode平台上的第622题——设计循环队列。循环队列是一种数据结构，它在数组或链表的基础上实现了队列的特点，同时通过巧妙的设计使得“出队”和“入队”的操作更为高效...
[数据结构] 基于交换的排序 冒泡排序&&快速排序
水墨不写bug
07-06 1085
让右下标先走，向左寻找比key小的值，找到后停下来：停下来后：左下标再向右寻找比key大的值，找到后停下来：此时，交换两个下标对应的值：接下来继续执行上述步骤（R先走），我展示关键步骤：两下标找到要求目标并交换：直到遇到特殊情况：两下标相遇这时停止停止循环，将最左侧元素与相遇处的元素交换位置：即可完成一次二分。
[数据结构] 基于插入的排序 插入排序&希尔排序
水墨不写bug
07-06 1135
插入排序&&希尔排序 实现原理
(5) 深入探索Python-Pandas库的核心数据结构：Series详解
架构筑梦的Cherry Yang的博客
07-06 1114
# 1. Series 简介 pandas数据结构中的Series是一个一维数组对象，能够保存任何数据类型（整数、字符串、浮点数、Python对象等），并有一个与之关联的标签序列，这些标签被称为“索引”（index）。索引与数据是一一对应的，通过索引可以快速获取、更新或删除数据。Series在pandas数据处理中起着至关重要的作用，是构建更复杂数据结构（如DataFrame）的基础。 以下是关于pandas Series的详细解释： * **定义**：Series类似于一维数组或列表，但它有一个显式的
数据结构第07节：队列
hummhumm的专栏
07-04 571
在计算机科学中，队列是一种抽象数据类型，它遵循先进先出（FIFO）原则，即最先加入队列的元素将是最先被移除的。在学生成绩管理系统中，队列可以用于管理等待处理的成绩更新请求，或者用于存储等待查询成绩的学生ID列表。请注意，这个实现假设所有学生ID都是整数，并且队列的大小是固定的。这个队列将用于管理学生的ID，模拟学生成绩管理系统中可能用到的队列操作。下面，我将以一个简单的学生成绩管理系统中的队列应用为例，用表格形式来详细讲解队列的操作和状态变化。类，它包含书籍的基本信息，例如书名、作者和ISBN号。
6、Redis系统-数据结构-03-压缩列表
最新发布
qq_29434541的博客
07-07 1188
由于压缩列表需要进行空间扩展操作，这就需要重新分配内存，因此连锁更新一旦发生，会导致压缩列表占用的内存空间多次重新分配，直接影响到压缩列表的访问性能。因此，虽然压缩列表紧凑型的内存布局能节省内存开销，但是如果保存的元素数量增加，或元素变大，会导致内存重新分配，最糟糕的是会引发「连锁更新」的问题。因此，虽然压缩列表紧凑型的内存布局能节省内存开销，但是如果保存的元素数量增加，或元素变大，会导致内存重新分配，最糟糕的是会引发「连锁更新」的问题。而当新插入的元素较大时，可能会导致后续元素的。
数据结构课程设计循环队列实现杨辉三角C语言
06-10
以下是使用C语言实现循环队列生成杨辉三角的代码，适合作为数据结构课程设计的实现： ```c #include <stdio.h> #include <stdlib.h> #define MAX_SIZE 100 // 定义循环队列 typedef struct { int front; // 队首指针 int rear; // 队尾指针 int items[MAX_SIZE]; // 队列元素 } Queue; // 初始化队列 void init_queue(Queue *q) { q->front = q->rear = 0; } // 判断队列是否为空 int is_empty(Queue *q) { return q->front == q->rear; } // 判断队列是否已满 int is_full(Queue *q) { return (q->rear + 1) % MAX_SIZE == q->front; } // 元素入队 void enqueue(Queue *q, int item) { if (!is_full(q)) { q->items[q->rear] = item; q->rear = (q->rear + 1) % MAX_SIZE; } } // 元素出队 int dequeue(Queue *q) { if (!is_empty(q)) { int item = q->items[q->front]; q->front = (q->front + 1) % MAX_SIZE; return item; } return -1; } // 生成杨辉三角 void generate_yanghui_triangle(int n) { Queue q; init_queue(&q); enqueue(&q, 1); // 第一行只有一个数字1 for (int i = 0; i < n; i++) { for (int j = 0; j <= i; j++) { printf("%d ", q.items[j]); } printf("\n"); for (int j = 0; j <= i; j++) { enqueue(&q, dequeue(&q) + q.items[j]); } enqueue(&q, 1); // 行末添加数字1 } } int main() { int n; printf("请输入杨辉三角的行数："); scanf("%d", &n); generate_yanghui_triangle(n); // 生成n行杨辉三角 return 0; } ``` 在主函数中，通过scanf函数获取用户输入的杨辉三角的行数n，并将n作为参数传递给generate_yanghui_triangle函数。这样就可以根据用户输入的行数生成相应的杨辉三角。代码中还可以添加一些错误处理机制，例如判断用户输入的行数是否超出范围等等。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

唐唐思

你的鼓励将是我创作的最大动力

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

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

打赏作者

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

抵扣说明：

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

余额充值