设计循环队列

最新推荐文章于 2024-07-10 16:47:58 发布
最新推荐文章于 2024-07-10 16:47:58 发布
阅读量1.2k 收藏 22
点赞数 35
分类专栏： 数据结构 文章标签： 算法 数据结构 链表 开发语言 c语言 visual studio
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80239034/article/details/136635748
版权
本文详细介绍了如何使用链表和数组两种数据结构实现循环队列，包括结构体设计、创建、插入、删除以及判断队列是否为空或已满的操作。
摘要由CSDN通过智能技术生成

目录

题目信息：

思路分析

思路一：链表

结构体的设计：

myCircleQueueCreate：

myCircleQueueFront：

myCircleQueueRear：

myCircleQueueEnQueue：

myCircleQueueDnQueue：

myCircleQueueIsEmpty：

myCircleQueueIsFull：

思路二：数组

结构体的设计：

MyCricleQueueCreate：

myCircleQueueFront： 

myCircleQueueRear：

myCircleQueueEnQueue：

myCircleQueueDnQueue：

myCircleQueueIsEmpty：

myCircleQueueIsFull：

源码：

链表：

Circle.h

Cricle.c

数组：

Queue.h

Queue.c

题目信息：

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

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

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

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

思路分析：

思路一：链表

结构体的设计：

链表实现循环队列为了便于取头部元素和尾部元素最好创建两个结构体，一个结构体放置链表信息，另一个结构体封装循环队列元素，其中封装循环队列元素的结构体放置head、tail、preTail、size、capacity。head指向头元素，用于获取头元素信息；tail指向尾元素的后一个元素，用来在队尾插入元素，preTail指向尾元，用于获取尾元素；size表示循环队列内元素个数；capacity表示循环队列内开辟的元素个数

typedef struct Qnode
{
    struct Qnode* next;
    int val;
}Qnode;

typedef struct MyCircularQueue {
    Qnode* head;
    Qnode* tail;
    Qnode* preTail;
    int size;
    int capacity;
} MyCircularQueue;

myCircleQueueCreate：

先对封装循环队列元素的结构体进行malloc开辟，将capacity置为参数k，在对循环链表每一个节点进行malloc开辟，配合while循环语句，开辟一个长度为k的循环队列

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;
}

myCircleQueueFront：

先判断队列的是否有元素，没有元素直接返回-1，有元素返回head节点的元素

myCircleQueueRear：

先判断队列的是否有元素，没有元素直接返回-1，有元素返回preTail节点的元素

//循环队列取对头元素
int myCircularQueueFront(MyCircularQueue* obj) {
    return obj->size == 0 ? -1 : obj->head->val;
}

//循环队列取队尾元素
int myCircularQueueRear(MyCircularQueue* obj) {
    return obj->size == 0 ? -1 : obj->preTail->val;
}

myCircleQueueEnQueue：

先判断队列是否满了，满了返回false，没满执行尾插：

将tail节点内存储元素，preTail指向tail节点的下一个，作为队尾，tail再指向preTail节点的下一个，用于下一个元素的插入，元素个数+1

//循环队列的插入
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;
}

myCircleQueueDnQueue：

先判断队列是否为空，为空返回false，不为空执行头删：

tail节点指向tail节点的下一个，元素个数-1

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

myCircleQueueIsEmpty：

判断循环队列的元素个数是不是0

//循环队列判空
bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    return obj->size == 0;
}

myCircleQueueIsFull：

判断循环队列的元素个数是不是等于队列长度

//循环队列判满
bool myCircularQueueIsFull(MyCircularQueue* obj) {
    return obj->size == obj->capacity;
}

思路二：数组

结构体的设计：

数组实现循环队列，创建的结构体元素包括指针a，头元素下标front，尾元素的下一个元素的下标rear和循环队列元素个数k

typedef struct MyCircleQueue
{
	int* a;
	int front;
	int rear;
	int k;
}MQ;

MyCricleQueueCreate：

开辟一个长度为k+1的数组（用于避免假溢出问题），结构体元素指针a指向开辟的数组的首元素的地址，front指向首元素下标，rear指向尾元素的下一个元素的下标，用来尾插元素，元素个数置为k

//循环队列的创建
MQ* myCircleQueueCreate(int k)
{
	MQ* obj = (MQ*)malloc(sizeof(MQ));
	int* arr = (int *)malloc(sizeof(int) * (k + 1));
	obj->a = arr;
	obj->front = 0;
	obj->rear = 0;
	obj->k = k;
    return obj;
}

myCircleQueueFront： 

先判断循环队列是否满了，满了就返回-1，没满就返回front下标的元素

//循环队列取队头元素
int myCircleQueueFront(MQ* obj)
{
	if (myCircleQueueIsEmpty)
	{
		return -1;
	}
	return obj->a[obj->front];
}

myCircleQueueRear：

先判断rear下标是否为0，如果下标为0，说明循环队列已经执行循环了，此时队尾元素就是下标为k-1的元素，如果rear下标不为0，则说明循环队列没有执行循环，此时队尾元素就是下标为rear-1的元素

//循环队列取队尾元素
int myCircleQueueRear(MQ* obj)
{
	if (obj->rear == 0)
	{
		return obj->a[obj->k - 1];
	}
    else
    {
        return obj->a[obj->rear - 1];
    }
}

myCircleQueueEnQueue：

先判断循环队列是否满了，如果满了，返回false，没满执行尾插：

将元素插入到数组rear下标所在位置，rear+1，判断+1后的rear是否超出循环队列可存储元素的个数，用rear/k+1，得到一个在（0，k）范围内的下标

//循环队列添加元素
bool myCircleQueueEnQueue(MQ* obj, int val)
{
	if (myCircleQueueIsFull)
	{
		return false;
	}
	obj->a[obj->rear] = val;
	obj->rear++;
	obj->rear = (obj->rear) / (obj->k + 1);
	return true;
}

myCircleQueueDnQueue：

先判断循环队列是否为空，如果为空，返回false，没空执行头删：

执行front+1，判断+1后的front是否超出循环队列可存储元素的个数，用front/k+1，得到一个在（0，k）范围内的下标

//循环队列删除元素
bool myCircleQueueDnQueue(MQ* obj)
{
	if (myCircleQueueIsEmpty)
	{
		return false;
	}
	obj->front++;
	obj->front = (obj->front) / (obj->k + 1);
	return true;
}

myCircleQueueIsEmpty：

判断头元素头元素下标和尾元素的后一个元素的下标是否相同

//循环队列的判断空
bool myCircleQueueIsEmpty(MQ* obj)
{
	return obj->front == obj->rear;
}

myCircleQueueIsFull：

//循环队列的判断满
bool myCircleQueueIsFull(MQ* obj)
{
	return (obj->rear + 1) / (obj->k + 1) == obj->front;
}

源码：

链表：

Circle.h

#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <stdbool.h>

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);

//循环队列的插入
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value);

//循环队列的删除
bool myCircularQueueDnQueue(MyCircularQueue* obj);

//循环队列取队头元素
int myCircularQueueFront(MyCircularQueue* obj);

//循环队列取队尾元素
int myCircularQueueRear(MyCircularQueue* obj);

//循环队列判空
bool myCircularQueueIsEmpty(MyCircularQueue* obj);

//循环队列判满
bool myCircularQueueIsFull(MyCircularQueue* obj);

//循环队列的释放
void myCircularQueueFree(MyCircularQueue* obj);

Cricle.c

#include "circle.h"
//循环队列的创建
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 myCircularQueueDnQueue(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);
}

数组：

Queue.h

#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <stdbool.h>
typedef struct MyCircleQueue
{
	int* a;
	int front;
	int rear;
	int k;
}MQ;

//循环队列的创建
MQ* myCircleQueueCreate(int k);

//循环队列的判断空
bool myCircleQueueIsEmpty(MQ* obj);

//循环队列的判断满
bool myCircleQueueIsFull(MQ* obj);

//循环队列添加元素
bool myCircleQueueEnQueue(MQ* obj, int val);

//循环队列删除元素
bool myCircleQueueDnQueue(MQ* obj);

//循环队列取队头元素
int myCircleQueueFront(MQ* obj);

//循环队列取队尾元素
int myCircleQueueRear(MQ* obj);

//循环队列的释放
void myCircleQueueFree(MQ* obj);

Queue.c

#include "Queue.h"
//循环队列的创建
MQ* myCircleQueueCreate(int k)
{
	MQ* obj = (MQ*)malloc(sizeof(MQ));
	int* arr = (int *)malloc(sizeof(int) * (k + 1));
	obj->a = arr;
	obj->front = 0;
	obj->rear = 0;
	obj->k = k;
}

//循环队列的判断空
bool myCircleQueueIsEmpty(MQ* obj)
{
	return obj->front == obj->rear;
}

//循环队列的判断满
bool myCircleQueueIsFull(MQ* obj)
{
	return (obj->rear + 1) / (obj->k + 1) == obj->front;
}

//循环队列添加元素
bool myCircleQueueEnQueue(MQ* obj, int val)
{
	if (myCircleQueueIsFull)
	{
		return false;
	}
	obj->a[obj->rear] = val;
	obj->rear++;
	obj->rear = (obj->rear) / (obj->k + 1);
	return true;
}

//循环队列删除元素
bool myCircleQueueDnQueue(MQ* obj)
{
	if (myCircleQueueIsEmpty)
	{
		return false;
	}
	obj->front++;
	obj->front = (obj->front) / (obj->k + 1);
	return true;
}

//循环队列取队头元素
int myCircleQueueFront(MQ* obj)
{
	if (myCircleQueueIsEmpty)
	{
		return -1;
	}
	return obj->a[obj->front];
}

//循环队列取队尾元素
int myCircleQueueRear(MQ* obj)
{
	//方式1:判断
	if (obj->rear == 0)
	{
		return obj->a[obj->k - 1];
	}
	//方式2：取%
	return (obj->a[obj->rear - 1 + obj->k + 1]) / obj->a[obj->k + 1];
}

//循环队列的释放
void myCircleQueueFree(MQ* obj)
{
	free(obj->a);
	free(obj);
}

PaPeR ..
关注
  • 35
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 7
    评论
专栏目录
【数据结构与算法】设计循环队列
Welcome home | Jian Liao 's blog
03-24 2697
🚩前面我们用队列实现了一个栈用栈实现了一个队列，相信大家随随便便轻松拿捏，而本章将带大家上点难度，我们来设计一个循环队列。🚩对于循环队列，重点就在一个“ 循环 ”，意思也就是该队列首尾相连形成一个环，但其本质还是不变，队列先进先出的性质依旧存在，只不过环的大小有限定（限定放多少数据就只能放多少数据）。🚩那么我们如何来设计这样的一个环，使它既能够像队列一样，又可以体现循环的性质？下面就带大家探讨一波。💝设计一个循环队列还是有些复杂的呢，不过看过本文章，相信大家也可以轻松拿捏。❤️‍🔥。
设计循环队列（LeetCode：622.设计循环队列）
qq_52777887的博客
03-16 1538
简单的接口调用实现循环队列！快来看看吧！
Leetcode 刷题 (11) 队列：设计循环队列
01-20
622. 设计循环队列 难度： 中等 题目分析： 看下面代码实现。参考的是裘宗燕的《数据结构与算法：Python语言描述》。此处不建议使用python内置的list的append, pop操作，使用了就违背设计循环队列的初衷：消除...
设计循环双端队列
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题——设计循环队列。循环队列是一种数据结构，它在数组或链表的基础上实现了队列的特点，同时通过巧妙的设计使得“出队”和“入队”的操作更为高效...
36. Adam 算法详解
最新发布
qq_41238579的博客
07-10 653
Adam（Adaptive Moment Estimation）是一种结合动量法和自适应学习率的优化算法，自2014年提出以来，迅速成为深度学习中最流行和常用的优化算法之一。Adam算法的核心思想是利用梯度的一阶动量和二阶动量来动态调整学习率，既保持了动量法的优点，又结合了RMSProp的自适应学习率特性。
D1.排序
2302_79232710的博客
07-07 185
快速排序和归并排序
【力扣】数组中的第K个最大元素
m0_61876562的博客
07-05 301
l, left]（该部分小于基准元素key）、[left + 1, right - 1]（等于基准元素key）、[right, r]（大于基准元素key）。3、计算每部分所包含的元素个数，分别为a 、b = right - left - 1、 c = r - right + 1;请注意，你需要找的是数组排序后的第。你必须设计并实现时间复杂度为。个最大的元素，而不是第。1、随机选择基准元素。
【排序 - 堆排序】
2302_80393814的博客
07-10 282
堆排序利用堆这种数据结构的特性，通过构建最大堆和不断调整堆的过程来实现排序。它的时间复杂度稳定在 O(n log n)，并且适用于大数据量的排序需求。通过本文，我们深入了解了堆排序的原理和实现方式，并通过C语言代码展示了如何实现堆排序算法。对于理解高效排序算法和算法设计有着重要的帮助。
每周算法：无向图的双连通分量
少儿编程乔老师
07-06 1236
通过Tarjan算法求无向连通图的双连通分量，计算至少添加多少条边可以将原图变为一个双连通分量。
【算法笔记自学】第 5 章 入门篇（3）——数学问题
qq_62704693的博客
07-06 1247
【代码】【算法笔记自学】入门篇（3）——数学问题。
算法库应用--Brute - Force算法串匹配(顺序串)
qq_57484399的博客
07-06 910
V1.0: 在原有的博客基础上, 加入我构建的算法库, 让博客更完全 , 代码可以运行看效果, 不是让算法仅仅停留在 逻辑方面, 这也是后续我努力的方向, 把这些算法模型, 尽可能的去运用到实际的嵌入式项目中, 把理论变成实物 , 本次也进行了名字优化, 让逻辑更清晰。利用B-f算法,寻找子串在母串中的位置。
算法力扣刷题 三十二【239. 滑动窗口最大值】
danaaaa的博客
07-05 674
单调队列（自定义一种队列规则）使用场景1.
力扣215 数组中第k大的数
东篱君的博客
07-10 78
算法：由于数组最大范围是10000，存在负数。申请一个20000的数组，将原数组的数作为新数组下标（+10000因为存在负数），然后从后往前减，求出第K大的数。请注意，你需要找的是数组排序后的第 k 个最大的元素，而不是第 k 个不同的元素。本题主要考察各种排序算法，要求时间O（n），严格意义上说只有计数排序满足条件。给定整数数组 nums 和整数 k，请返回数组中第 k 个最大的元素。你必须设计并实现时间复杂度为 O(n) 的算法解决此问题。
《算法笔记》总结No.4——散列
前端，算法，MATLAB，统计学爱好者，目前主攻Web全栈+考研内容
07-07 704
散列的英文名是hash，即我们常说的哈希~该知识点在王道408考研的教材里面属于的范围。即便各位并无深入了解过，也听说过散列是一种更高效的查找方法。
数据结构课程设计循环队列实现杨辉三角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函数。这样就可以根据用户输入的行数生成相应的杨辉三角。代码中还可以添加一些错误处理机制，例如判断用户输入的行数是否超出范围等等。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值