队列

最新推荐文章于 2024-10-04 18:59:43 发布
最新推荐文章于 2024-10-04 18:59:43 发布
阅读量86 收藏
点赞数
分类专栏： 知识总结——数据结构（基础） 文章标签： 队列 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Jokersorry/article/details/112077465
版权

目录

基本概念

  • 队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出 FIFO(First In First Out) 的性质。
  • 入队列：进行插入操作的一端称为队尾。
  • 出队列：进行删除操作的一端称为队头。
  • 入队 / 出队示意图：
    在这里插入图片描述

功能实现

  由于队列的操作时只在一端入队，在另一端出队，所以此处我们选择数组来实现的话，就会造成在数组尾入队 / 出队的时间复杂度虽然为 O(1)，但是在数组头出队 / 入队的时间复杂度为 O(n)，所以并不是最优选择。
  我们可以用链表来实现，并在头结点中多加一个尾指针指向尾结点，那么在链表头尾进行操作都是 O(1) 的时间复杂度，所以下面我们就使用链表来实现各种接口。
在这里插入图片描述

//这是 .h 部分的代码
#pragma once
//使用这种方式来重命名数据类型，这样可以很方便的修改后续数据的数据类型，相当于#define的作用
typedef int QueueType;

//创建队列
typedef struct Queue {
    //队列保存的数据
    QueueType _date;
    //指向下一个结点的指针
    struct Queue* _next;
}Queue;

//创建头结点
typedef struct QueueHead {
    //头结点中存放两个指针
    //指向首节点的指针
    Queue* _head;
    //指向尾结点的指针
    Queue* _tail;
}QHead;

//包含所有函数的声明
// 初始化队列 
void QueueInit(QHead* q);
//创建结点
Queue* QueueCenter(QueueType val);
// 队尾入队列 
void QueuePush(QHead* q, QueueType val);
// 队头出队列 
void QueuePop(QHead* q);
// 获取队列头部元素 
QueueType QueueFront(QHead* q);
// 获取队列队尾元素 
QueueType QueueBack(QHead* q);
// 获取队列中有效元素个数 
int QueueSize(QHead* q);
// 检测队列是否为空，如果为空返回非零结果，如果非空返回0 
int QueueEmpty(QHead* q);
// 销毁队列 
void QueueDestroy(QHead* q);

//这是 .c 部分的代码
#include<stdio.h>
#include<stdlib.h>
#include"queue.h"

// 初始化队列 
void QueueInit(QHead* q) {
	//参数合法性检验
	if (q == NULL) {
		return;
	}
	//初始化结点
	q->_head = q->_tail = NULL;
}

//创建结点
Queue* QueueCenter(QueueType val) {
	Queue* newNode = (Queue*)malloc(sizeof(Queue));
	newNode->_date = val;
	newNode->_next = NULL;
	return newNode;
}

// 队尾入队列 
void QueuePush(QHead* q, QueueType val) {
	//参数合法性检验
	if (q == NULL) {
		return;
	}
	//分两种情况插入
	//如果一个元素都没有，那么就让头指针和尾指针指向插入的节点
	if (q->_head == NULL) {
		q->_head = q->_tail = QueueCenter(val);
		return;
	}
	//如果有元素，那么就在尾结点后面插入一个元素，并修改尾指针指向
	q->_tail->_next = QueueCenter(val);
	q->_tail = q->_tail->_next;
}

// 队头出队列 
void QueuePop(QHead* q) {
	//参数合法性检验
	if (q == NULL) {
		return;
	}
	//保留头结点
	Queue* node = q->_head;
	//修改头结点指向
	q->_head = node->_next;
	//释放头结点
	free(node);
	//如果此时头指针指向空，那就说明队列空了，让为指针也指向空
	if (q->_head == NULL) {
		q->_tail = NULL;
	}
}

// 获取队列头部元素 
QueueType QueueFront(QHead* q) {
	//此处不好做参数合法性检验，因为不能以任何值作为出错后的返回值
	return q->_head->_date;
}

// 获取队列队尾元素 
QueueType QueueBack(QHead* q) {
	//此处不好做参数合法性检验，因为不能以任何值作为出错后的返回值
	return q->_tail->_date;
}

// 获取队列中有效元素个数 
int QueueSize(QHead* q) {
	//参数合法性检验
	if (q == NULL) {
		return 0;
	}
	//从队头结点开始遍历，如果不为空，计数器加一，更新指针
	Queue* node = q->_head;
	int count = 0;
	while (node) {
		count++;
		node = node->_next;
	}
	return count;
}

// 检测队列是否为空，如果为空返回非零结果，如果非空返回0 
int QueueEmpty(QHead* q) {
	//参数合法性检验，如果不合法直接返回不为0的数
	if (q == NULL || q->_head == NULL) {
		return 1;
	}
	return 0;
}

// 销毁队列 
void QueueDestroy(QHead* q) {
	//参数合法性检验
	if (q == NULL) {
		return;
	}
	//循环释放空间
	Queue* node = q->_head;
	q->_head = q->_tail = NULL;
	while (node) {
		Queue* temp = node;
		node = node->_next;
		free(temp);
	}
}

int main() {
	QHead head;
	QueueInit(&head);

	QueuePush(&head, 0);
	QueuePush(&head, 9);
	QueuePush(&head, 1);
	QueuePush(&head, 4);

	while (QueueEmpty(&head) == 0) {
		printf("%d\n", QueueFront(&head));
		QueuePop(&head);
	}

	return 0;
}

循环队列

  循环队列是一种特殊的队列，循环队列一般是固定好长度的，下面我用两种方法来实现循环队列；

数组方法

  数组创建循环队列；动态开辟所需大小的数组空间，设置两个标志位 front 和 rear，在一开始 front = rear =0 下标，而判空正是使用这个条件；但是判满就不能使用 front == rear，所以我们可以在申请空间时多申请一个结点，开辟 k + 1 个空间，因此判满的条件就是 rear + 1 == front，但是这样子很容易超出数组访问权限，所以条件变为 （rear + 1）%（k + 1）== front；
在这里插入图片描述

//这是 .h 部分的代码
#pragma once

//使用这种方式来重命名数据类型，这样可以很方便的修改后续数据的数据类型，相当于#define的作用
typedef int QueueType;

//使用数组创建循环队列
typedef struct MyCircularQueue {
    //首元素下标
    size_t _front;
    //尾元素下标
    size_t _rear;
    //动态开辟数组空间
    QueueType* _date;
    //数组大小
    size_t _k;
}MyCircularQueue;

//所有函数的声明
//数组循环队列初始化
void myCircularQueueInit(MyCircularQueue* obj, int k);
//数组循环队列入队
void myCircularQueueEnQueue(MyCircularQueue* obj, QueueType value);
//数组循环队列出队
void myCircularQueueDeQueue(MyCircularQueue* obj);
//返回数组循环队列队首元素
QueueType myCircularQueueFront(MyCircularQueue* obj);
//返回数组循环队列队尾元素
QueueType myCircularQueueRear(MyCircularQueue* obj);
//数组循环队列判空,为空返回非零值，非空返回 0
int myCircularQueueIsEmpty(MyCircularQueue* obj);
//数组循环队列判满，若满返回非零值，不满返回 0
int myCircularQueueIsFull(MyCircularQueue* obj);
//数组循环队列释放
void myCircularQueueFree(MyCircularQueue* obj);

//这是 .c 部分的代码
#include<stdio.h>
#include<stdlib.h>
#include"loopqueue.h"

//数组循环队列初始化
void myCircularQueueInit(MyCircularQueue* obj, int k) {
    //参数合法性检验
    if (obj == NULL) {
        return;
    }
    //数组大小为所能存储最大元素个数加一
    obj->_date = (int*)malloc(sizeof(int) * (k + 1));
    //数组大小 _k 就为 k + 1； 
    obj->_k = k + 1;
    obj->_front = obj->_rear = 0;
}

//数组循环队列入队
void myCircularQueueEnQueue(MyCircularQueue* obj, QueueType value) {
    //参数检验，如果队列满了，就返回
    if (obj == NULL || (obj->_rear + 1) % obj->_k == obj->_front) {
        return;
    }
    //插入元素，更新尾下标
    obj->_date[obj->_rear] = value;
    obj->_rear = (obj->_rear + 1) % obj->_k;
}

//数组循环队列出队
void myCircularQueueDeQueue(MyCircularQueue* obj) {
    //参数检查，如果队列为空，就返回
    if (obj == NULL || obj->_front == obj->_rear) {
        return;
    }
    //因为这是数组，所以就不需一个一个释放空间，只需将头下表变化即可
    obj->_front = (obj->_front + 1) % obj->_k;
}

//返回数组循环队列队首元素
QueueType myCircularQueueFront(MyCircularQueue* obj) {
    //此处参数检查不好做，返回任何值都有可能是队首元素
    return obj->_date[obj->_front];
}

//返回数组循环队列队尾元素
QueueType myCircularQueueRear(MyCircularQueue* obj) {
    //此处参数检查不好做，返回任何值都有可能是队首元素
    //此处需要注意，如果 _rear == 0，那么就不能返回 _rear -1 下标的元素，而是数组的最后一个元素，也就是 _k - 1 下标的元素
    if (obj->_rear == 0) {
        return obj->_date[obj->_k - 1];
    }
    return obj->_date[obj->_rear - 1];
}

//数组循环队列判空,为空返回非零值，非空返回 0
int myCircularQueueIsEmpty(MyCircularQueue* obj) {
    //参数合法性检验，如果 front == rear 就说明队列为空
    if (obj == NULL || obj->_front == obj->_rear) {
        return 1;
    }
    return 0;
}

//数组循环队列判满，若满返回非零值，不满返回 0
int myCircularQueueIsFull(MyCircularQueue* obj) {
    //参数合法性检验
    if (obj == NULL) {
        return 0;
    }
    //如果 (rear + 1) % k == front 就说明队列满了
    if ((obj->_rear + 1) % obj->_k == obj->_front) {
        return 1;
    }
    return 0;
}

//数组循环队列释放
void myCircularQueueFree(MyCircularQueue* obj) {
    //参数合法性检验
    if (obj == NULL) {
        return;
    }
    //释放自己动态申请的空间
    free(obj->_date);
}
链表方法

  链表创建循环队列；需要注意的是，链表的结点是一个一个申请的，所以无法像数组一样确定最后的结点，所以必须设置一个有效元素个数 size，一个所需结点个数 capacity，然后可以利用这两个数据的大小关系来确定循环队列的头尾；
  链表实现的循环队列看起来确实不太像循环的，但是因为有 capacity，这代表了最大的结点个数，所以当 size == capacity，那么就会满队列了；

//这是 .h 部分的代码
#pragma once

//使用这种方式来重命名数据类型，这样可以很方便的修改后续数据的数据类型，相当于#define的作用
typedef int QueueType;

//使用链表创建循环队列
//链表结点
typedef struct MyQueue {
    QueueType _date;
    struct MYQueue* _next;
}MyQueue;

typedef struct MyCircularQueue1 {
    //指向第一个结点
    MyQueue* _front;
    //指向最后一个节点，设置该指针是为了获取尾结点方便
    MyQueue* _rear;
    //有效元素个数
    size_t _size;
    //最大元素个数
    size_t _capacity;
}MyCircularQueue1;

//以链表方式创建循环队列
//链表循环队列初始化
void myCircularQueueInit1(MyCircularQueue1* obj, int k);
//开辟链表结点空间
MyQueue* myQueueCreate(QueueType value);
//链表循环队列入队
void myCircularQueueEnQueue1(MyCircularQueue1* obj, QueueType value);
//链表循环队列出队
void myCircularQueueDeQueue1(MyCircularQueue1* obj);
//返回链表循环队列队首元素
QueueType myCircularQueueFront1(MyCircularQueue1* obj);
//返回链表循环队列队尾元素
QueueType myCircularQueueRear1(MyCircularQueue1* obj);
//链表循环队列判空,为空返回非零值，非空返回 0
int myCircularQueueIsEmpty1(MyCircularQueue1* obj);
//链表循环队列判满,若满返回非零值，不满返回 0
void myCircularQueueIsFull1(MyCircularQueue1* obj);
//链表循环队列释放
void myCircularQueueFree1(MyCircularQueue1* obj);

//这是 .c 部分的代码
//链表循环队列初始化
void myCircularQueueInit1(MyCircularQueue1* obj, int k) {
    //参数合法性检验
    if (obj == NULL) {
        return;
    }
    obj->_front = obj->_rear = NULL;
    //一开始有效元素设置为 0，最大元素为 k
    obj->_size = 0;
    obj->_capacity = k;
}

//开辟链表结点空间
MyQueue* myQueueCreate(QueueType value) {
    //动态开辟结点
    MyQueue* mq = (MyQueue*)malloc(sizeof(MyQueue));
    mq->_date = value;
    mq->_next = NULL;
    return mq;
}

//链表循环队列入队
void myCircularQueueEnQueue1(MyCircularQueue1* obj, QueueType value) {
    //参数检查，如果队列满了，就返回
    if (obj == NULL || obj->_capacity == obj->_size) {
        return;
    }
    //分两种情况向队列中插入，若队列为空，则 front 和 rear 都指向插入的节点
    if (obj->_size == 0) {
        obj->_front = obj->_rear = myQueueCreate(value);
        obj->_size++;
    }
    //若队列非空，则在最后一个节点后插入，更新 rear 指针指向
    else {
        obj->_rear->_next = myQueueCreate(value);
        obj->_rear = obj->_rear->_next;
        obj->_size++;
    }
}

//链表循环队列出队
void myCircularQueueDeQueue1(MyCircularQueue1* obj) {
    //参数检查，空队列就返回
    if (obj == NULL || obj->_size == 0) {
        return;
    }
    //分两种情况插入，如果队列只有一个元素时，删除该节点，然后 front 和 rear 同时置NULL
    if (obj->_size == 1) {
        free(obj->_front);
        obj->_front = obj->_rear = NULL;
        obj->_size = 0;
    }
    //如果元素不为一，就删除第一个结点，然后修改 front 指向
    else {
        MyQueue* node = obj->_front;
        obj->_front = node->_next;
        free(node);
        obj->_size--;
    }
}

//返回链表循环队列队首元素
QueueType myCircularQueueFront1(MyCircularQueue1* obj) {
    //此处参数检查不好做，返回任何值都有可能是队首元素
    return obj->_front->_date;
}

//返回链表循环队列队尾元素
QueueType myCircularQueueRear1(MyCircularQueue1* obj) {
    //此处参数检查不好做，返回任何值都有可能是队首元素
    return obj->_rear->_date;
}

//链表循环队列判空,为空返回非零值，非空返回 0
int myCircularQueueIsEmpty1(MyCircularQueue1* obj) {
    //参数合法性检验
    if (obj == NULL || obj->_size == 0) {
        return 1;
    }
    return 0;
}

//链表循环队列判满,若满返回非零值，不满返回 0
void myCircularQueueIsFull1(MyCircularQueue1* obj) {
    //参数合法性检验
    if (obj == NULL) {
        return 0;
    }
    //当 _size == _capacity 就认为满了
    if (obj->_size == obj->_capacity) {
        return 1;
    }
    return 0;
}

//链表循环队列释放
void myCircularQueueFree1(MyCircularQueue1* obj) {
    //参数合法性检验
    if (obj == NULL) {
        return;
    }
    //循环释放动态申请的节点，直到 _size 等于 0 
    while (obj->_size) {
        MyQueue* node = obj->_front;
        obj->_front = node->_next;
        free(node);
        obj->_size--;
    }
    //全部置为 NULL 防止出现野指针
    obj->_rear = obj->_front = NULL;
}

int main() {
    //循环队列的长度
    int n = 10;

    MyCircularQueue q1;
    myCircularQueueInit(&q1, n);


    MyCircularQueue1 q2;
    myCircularQueueInit1(&q2, n);

	return 0;
}

简单练习

bfsm
关注
专栏目录
【SpringBoot】43、SpringBoot中整合RabbitMQ实现延时队列（延时插件篇）
Asurplus
02-21 21万+
一、介绍 1、什么是延时队列？ 延时队列即就是放置在该队列里面的消息是不需要立即消费的，而是等待一段时间之后取出消费 2、适用场景 （1）商城订单超时未支付，取消订单 （2）使用权限到期前十分钟提醒用户 （3）收益项目，投入后一段时间后产生收益 二、实现方式 从以上场景中，我们可以看出，延时队列的主要功能就是在指定的时间之后做指定的事情，那么，我们思考有哪些工具我们可以使用？ 1、Redis 监听过期 Key 可以参考我的博客【SpringBoot】三十五、SpringBoot整合Redis监听Ke
Redis Streams在Spring Boot中的应用：构建可靠的消息队列解决方案【redis实战 二】
热门推荐
todoitbo的博客
12-25 12万+
本文深入探讨了如何利用Spring Boot和Redis Streams构建一个高效、可靠的消息队列系统。从基本概念到高级实现，我们将一步步介绍如何在Spring Boot应用中集成Redis Streams，包括设置环境、消息的发布和订阅、处理消息以及监控和故障处理。通过本文，你将获得宝贵的实践知识，帮助你构建出能够处理高并发、高吞吐量场景的消息队列系统。
python 队列
cliffordl的专栏
02-20 4928
Queue.qsize() 返回队列的大小Queue.empty() 如果队列为空，返回True,反之FalseQueue.full() 如果队列满了，返回True,反之False，Queue.full 与 maxsize 大小对应Queue.get([block[, timeout]])获取队列，timeout等待时间Queue.get_nowait() 相当于Queue.get(False)，非阻塞方法Queue.put(item) 写入队列，timeout等待时间。
【SpringBoot】SpringBoot整合RabbitMQ消息中间件，实现延迟队列和死信队列
qq_61024956的博客
06-08 8349
RabbitMQ的死信队列（Dead Letter Queue，DLQ）是一种特殊的队列，用于接收其他队列中的“死信”消息。所谓“死信”，是指满足一定条件而无法被消费者正确处理的消息，这些条件包括消息被拒绝、消息过期、消息达到最大重试次数等。当消息成为死信时，RabbitMQ会将其重新发送到指定的死信队列，而不是丢弃它们。这样做的好处是可以对死信进行分析和处理，例如记录日志、重新入队或者进一步处理。
消息中间件（消息队列）
骑个小蜗牛的博客
02-19 2万+
消息中间件
FreeRTOS 队列管理
123
01-08 1万+
基于 FreeRTOS 的应用程序由一组独立的任务构成——每个任务都是具有独立权限的小程序。这些独立的任务之间很可能会通过相互通信以提供有用的系统功能。FreeRTOS 中所有的通信与同步机制都是基于队列实现的。 ...
延时 队列
ChineseSoftware的博客
03-07 1万+
一、什么是延时队列 延时队列相比于普通队列最大的区别就体现在其延时的属性上，普通队列的元素是先进先出，按入队顺序进行处理，而延时队列中的元素在入队时会指定一个延迟时间，表示其希望能够在经过该指定时间后处理。从某种意义上来讲，延迟队列的结构并不像一个队列，而更像是一种以时间为权重的有序堆结构。 二、延时队列的应用 技术没有最好的只有最合适的。 延时队列在项目中的应用还是比较多的，尤其像电商类平台： 12306 下单成功后，在半个小时内没有支付，自动取消订单。 如果订单一直处于某一个未完结状态时，及时处理关单
消息队列
weixin_41924879的博客
09-19 5451
消息队列 “消息队列”是在消息的传输过程中保存消息的容器，当我们需要使用消息的时候可以取出消息供自己使用。 消息队列中间件是分布式系统中重要的组件，主要解决应用解耦，异步消息，流量削锋等问题，实现高性能，高可用，可伸缩和最终一致性架构。目前使用较多的消息队列有ActiveMQ，RabbitMQ，ZeroMQ，Kafka，MetaMQ，RocketMQ。 为什么要用消息队列 (1) 通过异步处理...
队列 详解
Bit_Dong的博客
06-16 1713
队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。队列中没有元素时，称为空队列。队列的数据元素又称为队列元素。在队列中插入一个队列元素称为入队，从队列中删除一个队列元素称为出队。因为队列只允许在一端插入，在另一端删除，所以只有最早进入队列的元素才能最先从队列中删除，故队列又称为先进先出（FIFO—first in first out）线性表。...
java队列实现方法(顺序队列,链式队列,循环队列)
08-28
Java 队列实现方法 Java 队列是一种常用的数据结构，用于实现先进先出（FIFO）或后进先出（LIFO）的操作。Java 中提供了多种实现队列的方法，包括顺序队列、链式队列和循环队列等。下面我们将详细介绍每种队列的...
头歌数据结构循环队列及链队列的基本操作
05-18
在本文中，我们将深入探讨头歌数据结构中的两种基本数据结构——循环队列和链队列，以及它们在实现过程中的基本操作。首先，我们来理解这两种数据结构的概念。 循环队列是一种线性数据结构，它模拟了现实生活中的...
循环队列详解及队列的顺序表示和实现
08-31
循环队列是一种特殊的线性数据结构，它利用数组的“环状”特性来解决顺序队列中的“假溢出”问题。在顺序队列中，当队首和队尾指针相遇时，如果数组未满，实际上还有空间，但在逻辑上却表现为队列已满，这称为假溢出...
【算法竞赛】堆
Sakura_ding的博客
10-01 995
堆是一种树形结构,树的根是堆顶,堆顶始终保持为所有元素的最优值。有最大堆和最小堆,最大堆的根节点是最大值,最小堆的根节点是最小值。本节都以最小堆为例进行讲解。堆一般用二叉树实现,称为二叉堆。二叉堆的典型应用有堆排序和优先队列。
课设实验-数据结构-线性表-手机销售
ADCvbV的博客
10-02 347
【代码】数据结构-线性表-课设实验-手机销售。
【数据结构】【顺序表算法】 删除特定范围内的元素
最新发布
Indigo____的博客
10-04 248
题目：从顺序表中删除其值在给定值s和t之间（s<t）的所有元素，若s或t不合理或顺序表为空，则显示错误信息并退出运行。
（JAVA）队列 和 符号表 两种数据结构的实现
ZunXin_2580的博客
09-27 675
如果想要清晰的认识队列或者符号表是怎样的结构，那么就来看看这篇文章吧！！
数据结构之AVL树（万字详解）
都市隸人的博客
09-29 1089
本文介绍了数据结构中的AVL树，给出了C++的代码实现
C++实现顺序队列与链式队列
"顺序队列和链式队列的实现" 在计算机科学中，队列是一种基本的数据结构，它遵循“先进先出”（First In First Out, FIFO）的原则。顺序队列和链式队列是两种常见的队列实现方式。 顺序队列，也称为数组队列，是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值