队列。。。

转载 已于 2025-05-15 15:49:01 修改 · 54 阅读 · 0 ·
CC 4.0 BY-SA版权
原文链接：https://www.bilibili.com/video/BV1tNpbekEht?spm_id_from=333.788.videopod.episodes&vd_source=b4c5fa9eb7533ad728c71a812b423f46&p=6
文章标签：

#数据结构

于 2025-05-07 12:33:09 首次发布

test1

#include <stdio.h>

// 定义队列的最大容量
#define MAXSIZE 100
// 定义队列中元素的数据类型为整型
typedef int ElemType;

// 定义队列结构体
typedef struct 
{
    // 用于存储队列元素的数组，大小为 MAXSIZE
    ElemType data[MAXSIZE];
    // 队头指针，指示队列头部元素的位置
    int front;
    // 队尾指针，指示队列尾部元素的下一个位置
    int rear;
} Queue;

// 初始化队列
void initQueue(Queue *Q)
{
    // 将队头指针初始化为 0
    Q->front = 0;
    // 将队尾指针初始化为 0
    Q->rear = 0;
}

// 判断队列是否为空
int isEmpty(Queue *Q)
{
    // 当队头指针和队尾指针相等时，队列中没有元素，队列为空
    if (Q->front == Q->rear)
    {
        // 打印提示信息
        printf("空的\n");
        return 1;
    }
    else
    {
        return 0;	
    }
}

// 出队操作
ElemType dequeue(Queue *Q)
{
    // 检查队列是否为空
    if (Q->front == Q->rear)
    {
        // 若为空，打印提示信息并返回 0
        printf("空的\n");
        return 0;
    }
    // 取出队头元素
    ElemType e = Q->data[Q->front];
    // 队头指针向后移动一位
    Q->front++;
    return e;
}

// 队列满时调整队列
int queueFull(Queue *Q)
{
    // 当队头指针大于 0 时，说明队列前面有空闲空间
    if (Q->front > 0)
    {
        // 记录队头指针的值，即需要向前移动的步数
        int step = Q->front;
        // 将队列中的元素向前移动 step 个位置
        for (int i = Q->front; i < Q->rear; ++i)
        {
            Q->data[i - step] = Q->data[i];
        }
        // 队头指针重置为 0
        Q->front = 0;
        // 队尾指针相应地向前移动 step 个位置
        Q->rear = Q->rear - step;
        return 1;
    }
    else
    {
        // 队头指针为 0，说明队列真正满了，没有空闲空间可调整
        printf("真的满了\n");
        return 0;
    }
}

// 入队操作
int equeue(Queue *Q, ElemType e)
{
    // 检查队尾指针是否超出了队列的最大容量
    if (Q->rear >= MAXSIZE)
    {
        // 尝试调整队列
        if(!queueFull(Q))
        {
            // 调整失败，说明队列确实已满，入队失败
            return 0;
        }
    }
    // 将元素 e 放入队尾位置
    Q->data[Q->rear] = e;
    // 队尾指针向后移动一位
    Q->rear++;
    return 1;
}

// 获取队头元素
int getHead(Queue *Q, ElemType *e)
{
    // 检查队列是否为空
    if (Q->front == Q->rear)
    {
        // 若为空，打印提示信息并返回 0
        printf("空的\n");
        return 0;
    }
    // 将队头元素的值赋给指针 e 所指向的内存位置
    *e = Q->data[Q->front];
    return 1;
}

int main(int argc, char const *argv[])
{
    // 定义一个队列变量
    Queue q;
    // 初始化队列
    initQueue(&q);

    // 依次将元素 10、20、30、40、50 入队
    equeue(&q, 10);
    equeue(&q, 20);
    equeue(&q, 30);
    equeue(&q, 40);
    equeue(&q, 50);

    // 进行出队操作，并打印出队元素
    printf("%d\n",dequeue(&q));
    printf("%d\n",dequeue(&q));

    // 用于存储队头元素的变量
    ElemType e;
    // 获取队头元素
    getHead(&q, &e);
    // 打印队头元素
    printf("%d\n",e);

    return 0;
}

 test2

#include <stdio.h>
#include <stdlib.h>

// 定义队列的最大容量
#define MAXSIZE 100
// 定义队列元素的数据类型为整型
typedef int ElemType;

// 定义队列的结构体
typedef struct 
{
    // 指向存储队列元素的数组的指针
    ElemType *data;
    // 队头指针，指示队列头部元素的位置
    int front;
    // 队尾指针，指示队列尾部元素的下一个位置
    int rear;
} Queue;

// 初始化队列
Queue* initQueue()
{
    // 为队列结构体分配内存
    Queue *q = (Queue*)malloc(sizeof(Queue));
    // 为存储队列元素的数组分配内存，大小为 MAXSIZE 个 ElemType 类型元素
    q->data = (ElemType*)malloc(sizeof(ElemType) * MAXSIZE);
    // 初始化队头指针为 0
    q->front = 0;
    // 初始化队尾指针为 0
    q->rear = 0;
    return q;
}

// 判断队列是否为空
int isEmpty(Queue *Q)
{
    // 当队头指针和队尾指针相等时，说明队列为空
    if (Q->front == Q->rear)
    {
        printf("空的\n");
        return 1;
    }
    else
    {
        return 0;	
    }
}

// 出队操作
ElemType dequeue(Queue *Q)
{
    // 检查队列是否为空
    if (Q->front == Q->rear)
    {
        printf("空的\n");
        return 0;
    }
    // 取出队头元素
    ElemType e = Q->data[Q->front];
    // 队头指针向后移动一位
    Q->front++;
    return e;
}

// 队列满了，调整队列
int queueFull(Queue *Q)
{
    // 如果队头指针大于 0，说明队列前面有空闲空间
    if (Q->front > 0)
    {
        // 记录队头指针的值，作为移动的步数
        int step = Q->front;
        // 将队列中的元素向前移动 step 个位置
        for (int i = Q->front; i <= Q->rear; ++i)
        {
            Q->data[i - step] = Q->data[i];
        }
        // 队头指针重置为 0
        Q->front = 0;
        // 队尾指针相应地向前移动 step 个位置
        Q->rear = Q->rear - step;
        return 1;
    }
    else
    {
        // 队头指针为 0，说明队列真正满了
        printf("真的满了\n");
        return 0;
    }
}

// 入队操作
int equeue(Queue *Q, ElemType e)
{
    // 检查队尾指针是否超出了队列的最大容量
    if (Q->rear >= MAXSIZE)
    {
        // 尝试调整队列
        if(!queueFull(Q))
        {
            // 调整失败，入队操作失败
            return 0;
        }
    }
    // 将元素 e 放入队尾位置
    Q->data[Q->rear] = e;
    // 队尾指针向后移动一位
    Q->rear++;
    return 1;
}

// 获取队头元素
int getHead(Queue *Q, ElemType *e)
{
    // 检查队列是否为空
    if (Q->front == Q->rear)
    {
        printf("空的\n");
        return 0;
    }
    // 将队头元素的值赋给指针 e 所指向的内存位置
    *e = Q->data[Q->front];
    return 1;
}

int main(int argc, char const *argv[])
{
    // 初始化一个队列
    Queue *q = initQueue();

    // 依次将元素 10、20、30、40、50 入队
    equeue(q, 10);
    equeue(q, 20);
    equeue(q, 30);
    equeue(q, 40);
    equeue(q, 50);

    // 进行出队操作，并打印出队元素
    printf("%d\n",dequeue(q));
    printf("%d\n",dequeue(q));

    // 用于存储队头元素的变量
    ElemType e;
    // 获取队头元素
    getHead(q, &e);
    // 打印队头元素
    printf("%d\n",e);

    return 0;
}

test3 

#include <stdio.h>
#include <stdlib.h>

// 定义队列的最大容量
#define MAXSIZE 100
// 定义队列中元素的类型为整数
typedef int ElemType;

// 定义队列的结构体
typedef struct 
{
    // 用于存储队列元素的数组指针
    ElemType *data;
    // 队列头指针，指向队列头部元素的位置
    int front;
    // 队列尾指针，指向队列尾部元素的下一个位置
    int rear;
} Queue;

// 初始化队列
Queue* initQueue()
{
    // 为队列结构体分配内存
    Queue *q = (Queue*)malloc(sizeof(Queue));
    // 为队列的数据数组分配内存，大小为 MAXSIZE 个 ElemType 元素
    q->data = (ElemType*)malloc(sizeof(ElemType) * MAXSIZE);
    // 初始化队列头指针为 0
    q->front = 0;
    // 初始化队列尾指针为 0
    q->rear = 0;
    return q;
}

// 判断队列是否为空
int isEmpty(Queue *Q)
{
    // 当队列头指针和尾指针相等时，队列为空
    if (Q->front == Q->rear)
    {
        printf("空的\n");
        return 1;
    }
    else
    {
        return 0;
    }
}

// 入队操作，将元素 e 加入队列尾部
int equeue(Queue *Q, ElemType e)
{
    // 判断队列是否已满，使用取模运算处理循环队列
    if ((Q->rear + 1) % MAXSIZE == Q->front)
    {
        printf("满了\n");
        return 0;
    }
    // 将元素 e 放入队列尾部
    Q->data[Q->rear] = e;
    // 更新队列尾指针，使用取模运算实现循环
    Q->rear = (Q->rear + 1) % MAXSIZE;
    return 1;
}

// 出队操作，将队列头部元素取出并存储到 e 中
int dequeue(Queue *Q, ElemType *e)
{
    // 检查队列是否为空
    if (Q->front == Q->rear)
    {
        printf("空的\n");
        return 0;
    }
    // 将队列头部元素存储到 e 中
    *e = Q->data[Q->front];
    // 更新队列头指针，使用取模运算实现循环
    Q->front = (Q->front + 1) % MAXSIZE;
    return 1;
}

// 获取队列头部元素
int getHead(Queue *Q, ElemType *e)
{
    // 检查队列是否为空
    if (Q->front == Q->rear)
    {
        printf("空的\n");
        return 0;
    }
    // 将队列头部元素存储到 e 中
    *e = Q->data[Q->front];
    return 1;
}

int main(int argc, char const *argv[])
{
    // 初始化一个队列
    Queue *q = initQueue();

    // 依次将元素 10、20、30、40、50 入队
    equeue(q, 10);
    equeue(q, 20);
    equeue(q, 30);
    equeue(q, 40);
    equeue(q, 50);

    // 用于存储出队元素的变量
    ElemType e;
    // 进行一次出队操作
    dequeue(q, &e);
    // 打印出队的元素
    printf("%d\n", e);
    // 再进行一次出队操作
    dequeue(q, &e);
    // 打印出队的元素
    printf("%d\n", e);

    // 获取队列头部元素
    getHead(q, &e);
    // 打印队列头部元素
    printf("%d\n", e);

    return 0;
}

test4

#include <stdio.h>
#include <stdlib.h>

// 定义队列中元素的类型为整数
typedef int ElemType;

// 定义队列节点的结构体
typedef struct QueueNode
{
    // 存储节点的数据
    ElemType data;
    // 指向下一个节点的指针
    struct QueueNode *next;
} QueueNode;

// 定义队列的结构体
typedef struct 
{
    // 指向队列头节点的指针
    QueueNode *front;
    // 指向队列尾节点的指针
    QueueNode *rear;
} Queue;

// 初始化队列
Queue* initQueue()
{
    // 为队列结构体分配内存
    Queue *q = (Queue*)malloc(sizeof(Queue));
    // 为队列的头节点分配内存
    QueueNode *node = (QueueNode*)malloc(sizeof(QueueNode));
    // 头节点的数据初始化为 0
    node->data = 0;
    // 头节点的下一个节点初始化为 NULL
    node->next = NULL;
    // 队列的头指针指向头节点
    q->front = node;
    // 队列的尾指针也指向头节点，此时队列为空
    q->rear = node;
    return q;
}

// 判断队列是否为空
int isEmpty(Queue *q)
{
    // 如果队列的头指针和尾指针相等，说明队列为空
    if (q->front == q->rear)
    {
        return 1;
    }
    else
    {
        return 0;
    }
}

// 入队操作，将元素 e 加入队列尾部
void equeue(Queue *q, ElemType e)
{
    // 为新节点分配内存
    QueueNode *node = (QueueNode*)malloc(sizeof(QueueNode));
    // 新节点的数据设置为 e
    node->data = e;
    // 新节点的下一个节点初始化为 NULL
    node->next = NULL;
    // 将新节点连接到队列尾部
    q->rear->next = node;
    // 更新队列的尾指针指向新节点
    q->rear = node;
}

// 出队操作，将队列头部元素取出并存储到 e 中
int dequeue(Queue *q, ElemType *e)
{
    // 检查队列是否为空
    if (isEmpty(q))
    {
        printf("空的\n");
        return 0;
    }

    // 找到队列头部的第一个有效节点
    QueueNode *node = q->front->next;
    // 将该节点的数据存储到 e 中
    *e = node->data;
    // 更新队列的头指针，跳过该节点
    q->front->next = node->next;
    // 如果出队的节点是队列的最后一个节点
    if (q->rear == node)
    {
        // 将队列的尾指针指向头节点，使队列再次为空
        q->rear = q->front;
    }
    // 释放出队节点的内存
    free(node);
    return 1;
}

// 获取队列头部元素
ElemType getFront(Queue *q)
{
    // 检查队列是否为空
    if (isEmpty(q))
    {
        printf("空的\n");
        return 0;
    }
    // 返回队列头部的第一个有效节点的数据
    return q->front->next->data;
}

int main(int argc, char const *argv[])
{
    // 初始化一个队列
    Queue *q = initQueue();
    // 依次将元素 10、20、30、40、50 入队
    equeue(q, 10);
    equeue(q, 20);
    equeue(q, 30);
    equeue(q, 40);
    equeue(q, 50);
    // 用于存储出队元素的变量
    ElemType e;
    // 进行一次出队操作
    dequeue(q, &e);
    // 打印出队的元素
    printf("出队%d\n", e);
    // 再进行一次出队操作
    dequeue(q, &e);
    // 打印出队的元素
    printf("出队%d\n", e);
    // 打印队列头部的元素
    printf("%d\n", getFront(q));
    return 0;
}

 

 

01292520
关注
队列
jxc47的博客
09-13 6663
队列 定义：队列是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。 队列（Queue）是一种先进先出（First In First Out）的线性表，简称FIFO。 允许插入的一端叫做队尾，删除的一端叫做队头。 同样是线性表，队列也有类似的操作。不同的是队列是在队尾插入数据，在队头删除数据。 队列的基本操作 1. getSize（） 获取队列中有效元素的个数 2. isEmpty（...
Java阻塞队列解析：挑战并发编程中的瓶颈
热门推荐
张彦峰的博客
05-12 170万+
本文介绍了Java中的阻塞队列（BlockingQueue），重点讲解了其基本概念、常见实现及应用场景。通过分析生产者-消费者问题的解决方案，帮助开发者理解如何利用阻塞队列优化并发编程，提高系统效率与稳定性。
Python 队列
cliffordl的专栏
02-20 1万+
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等待时间。
FreeRTOS 队列
m0_60633015的博客
07-11 1876
因为同一个队列可以被多个任务读取，因此可能会有多个任务因等待同一个队列，而被阻 塞，在这种情况下，如果队列中有可用的消息，那么也只有一个任务会被解除阻塞并读取到消 息，并且会按照阻塞的先后和任务的优先级，决定应该解除哪一个队列读取阻塞任务。当想某一个队列写入数据时，如果此时的队列已经满了，就是没有空位置了，这时任务实际上是阻塞住了，因为想要写入但是无法写入，我们可以设定一个等待阻塞时间，等待的时间在设定范围内，任务就会被添加到阻塞列表中进行等待，等待队列中有空位置。uxItemSize就是队列项目的大小。
DS初阶：链式结构实现队列
weixin_51142926的博客
02-12 7696
队列：是只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出FIFO(First In First Out)的特点。让我们一起学习吧！！
FreeRTOS 队列管理
123
01-08 1万+
基于 FreeRTOS 的应用程序由一组独立的任务构成——每个任务都是具有独立权限的小程序。这些独立的任务之间很可能会通过相互通信以提供有用的系统功能。FreeRTOS 中所有的通信与同步机制都是基于队列实现的。 ...
延时 队列
ChineseSoftware的博客
03-07 1万+
一、什么是延时队列 延时队列相比于普通队列最大的区别就体现在其延时的属性上，普通队列的元素是先进先出，按入队顺序进行处理，而延时队列中的元素在入队时会指定一个延迟时间，表示其希望能够在经过该指定时间后处理。从某种意义上来讲，延迟队列的结构并不像一个队列，而更像是一种以时间为权重的有序堆结构。 二、延时队列的应用 技术没有最好的只有最合适的。 延时队列在项目中的应用还是比较多的，尤其像电商类平台： 12306 下单成功后，在半个小时内没有支付，自动取消订单。 如果订单一直处于某一个未完结状态时，及时处理关单
消息中间件（消息队列）
骑个小蜗牛的博客
02-19 3万+
消息中间件
FreeRTOS 消息队列
上山的月的博客
08-23 1637
FreeRTOS队列是任务间通信的关键，具备阻塞特性以保证数据有序。队列结构体灵活，既适用于数据队列也支持互斥信号量。核心操作有创建、入队与出队，分别通过xQueueCreate()、xQueueSendToFront()/xQueueSend()及xQueueReceive()实现。实验表明，多任务环境下队列能有效同步数据，提升系统性能。总之，掌握FreeRTOS队列操作对理解其内核机制至关重要，为实时系统设计提供可靠通信保障。
JAVA队列（ Queue ) 详解
叶新东老师的博客
04-24 8万+
什么是队列？ 队列是一种特殊的线性表，遵循先入先出、后入后出的基本原则，一般来说，它只允许在表的前端进行删除操作，而在表的后端进行插入操作，但是java的某些队列运行在任何地方插入删除；比如我们常用的 LinkedList 集合，它实现了Queue 接口，因此，我们可以理解为LinkedList 就是一个队列； java队列特性 队列主要分为阻塞和非阻塞，有界和无界、单向链表和双向链表之分； 阻塞和非阻塞 阻塞队列 入列(删除元素)时，如果元素数量超过队列总数......
消息队列
weixin_41924879的博客
09-19 5503
消息队列 “消息队列”是在消息的传输过程中保存消息的容器，当我们需要使用消息的时候可以取出消息供自己使用。 消息队列中间件是分布式系统中重要的组件，主要解决应用解耦，异步消息，流量削锋等问题，实现高性能，高可用，可伸缩和最终一致性架构。目前使用较多的消息队列有ActiveMQ，RabbitMQ，ZeroMQ，Kafka，MetaMQ，RocketMQ。 为什么要用消息队列 (1) 通过异步处理...
直击高频编程考点：队列知识及经典算法题总结
张彦峰的博客
04-09 5万+
队列知识及编程练习总结：背景知识 +队列的应用（在Spring中的应用+在其他框架中的应用+在实际开发中的应用）+相关编程练习（用队列实现栈+使用栈实现队列+设计循环队列+滑动窗口最大值 +课程表+队列的最大值+用数组实现一个队列）
异步处理优化：多线程线程池与消息队列的选择与应用
张彦峰的博客
12-01 169万+
本文讨论了两种常见的异步处理方式：多线程线程池和消息队列（MQ）。通过将非核心逻辑异步化，可以提升系统的性能和响应速度。多线程线程池适用于本地并发任务，适合需要快速响应的场景，但无法处理跨服务任务。消息队列则适用于分布式系统，能够解耦服务并保证任务的可靠性和顺序性，适合处理高并发和高可靠性要求的任务。文章提供了实际代码示例，帮助开发者根据业务需求选择合适的异步处理方式。
数据结构2.（双向链表，循环链表及内核链表）
2401_89312016的博客
08-05 645
本文详细介绍了三种链表的实现方法：双向链表、循环链表和内核链表。双向链表部分包含节点定义、创建、头插/尾插法、遍历、查找、修改、删除等操作实现；循环链表在双向链表基础上增加了循环特性，调整了遍历条件；内核链表部分分析了Linux内核中的链表实现，包括节点定义、初始化、插入/删除操作以及各类遍历宏定义。全文通过代码示例展示了链表的核心操作，重点比较了不同链表类型在实现上的差异，特别是循环链表和内核链表在结构设计和操作实现上的优化技巧。
数据结构04 栈和队列
LI1109hd的博客
08-05 272
/队列: 先进先出。
数据结构——图及其C++实现 多源最短路径 FloydWarshall算法
学习日记
08-06 945
前两篇学习的Dijkstra算法和Bellman-Ford算法都是用来求解图的单源最短路径，即从图中指定的一个源点出发到图中其他任意顶点的最短路径。Dijkstra算法不能求解带有负权重的图的最短路径，而Bellman-Ford算法弥补了这个缺点。本篇文章再来见识一下一个求解多源最短路径的算法——Floyd-Warshall算法。多源最短路径–Floyd-Warshall算法Floyd-Warshall算法是一种解决多源最短路径问题（任意两点间的最短路径）的算法。
嵌入式 - 数据结构：循环链表和内核链表
m0_74911141的博客
08-05 496
/ 数据域// 前驱指针// 后继指针} linknode;// 首尾自环Linux 内核中通过// 后继指针// 前驱指针初始化初始化头节点，使其首尾自环；插入（头插）、（尾插）；删除从链表中移除节点；遍历遍历数据元素，其中member为数据结构中成员的名称；数据定位通过节点指针ptr找到数据结构的首地址（核心宏，通过指针运算实现）。使用内核链表时，需在自定义数据结构中嵌入// 示例：定义一个包含内核链表节点的进程结构int pid;// 进程ID// 进程名。
排序概念以及插入排序
最新发布
2503_92099422的博客
08-09 312
c.虽然很多算法本身具有稳定或不稳定排序性质但是任何排序只要稍作修改就可以修改稳定性，例如在冒泡排序中判断交换顺序的依据是if(a>b)只要变成if(a>=b)就可以破坏稳定性。2.内部排序和外部排序：待排序数据可以一次性载入到内存中为内部排序，反之数据量过大就是外部排序。3.稳定排序：排序前后序列中键值相等的元素在相对位置不发生变化的就是稳定排序。就地排序只是在原数组空间进行排序处理，也就是输入的数组和得到的数组是同一个。3.如果待排序的元素，已经有序，只有极个别的元素是无序,插入速度较快。
Java队列实现详解：顺序队列、链式队列与循环队列
在计算机科学和编程领域中，队列是一种抽象的数据结构，用于在特定的顺序下处理元素集合。队列的基本操作包括入队（enqueue）和出队（dequeue），遵循先进先出（FIFO）的原则。Java语言提供了多种方式来实现队列，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值