【数据结构：C语言版】005：C语言中的队列-普通、双端与优先级实现

最新推荐文章于 2024-09-04 15:17:01 发布
最新推荐文章于 2024-09-04 15:17:01 发布
阅读量485 收藏 9
点赞数 20
分类专栏： 数据结构C语言版 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2403_83044722/article/details/141673674
版权

        队列是一种遵循先进先出（FIFO）原则的线性数据结构。它在许多场景中都有广泛应用，如任务调度、缓冲区管理等。本文将介绍三种常见的队列类型：普通队列、双端队列和优先队列，并提供它们在C语言中的实现。

1. 普通队列

        普通队列是最基本的队列类型，只允许在一端（称为队尾）插入元素，在另一端（称为队首）删除元素。

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

#define MAX_SIZE 100

typedef struct {
    int items[MAX_SIZE];
    int front;
    int rear;
} Queue;

void initQueue(Queue *q) {
    q->front = -1;
    q->rear = -1;
}

int isEmpty(Queue *q) {
    return q->front == -1;
}

int isFull(Queue *q) {
    return (q->rear + 1) % MAX_SIZE == q->front;
}

void enqueue(Queue *q, int value) {
    if (isFull(q)) {
        printf("Queue is full\n");
        return;
    }
    if (isEmpty(q)) {
        q->front = 0;
    }
    q->rear = (q->rear + 1) % MAX_SIZE;
    q->items[q->rear] = value;
}

int dequeue(Queue *q) {
    if (isEmpty(q)) {
        printf("Queue is empty\n");
        return -1;
    }
    int item = q->items[q->front];
    if (q->front == q->rear) {
        // Last element
        q->front = -1;
        q->rear = -1;
    } else {
        q->front = (q->front + 1) % MAX_SIZE;
    }
    return item;
}

int main() {
    Queue q;
    initQueue(&q);

    enqueue(&q, 10);
    enqueue(&q, 20);
    enqueue(&q, 30);

    printf("Dequeued: %d\n", dequeue(&q));
    printf("Dequeued: %d\n", dequeue(&q));

    return 0;
}

/* 运行结果：
Dequeued: 10
Dequeued: 20
*/

这个实现使用了循环数组来避免假溢出问题，使得队列可以更有效地利用数组空间。

应用场景

  1. 进程调度：操作系统使用队列来管理等待执行的进程。
  2. 缓冲区管理：在数据传输中，队列用于管理数据缓冲区，如打印机任务队列。
  3. 广度优先搜索（BFS）：在图的遍历算法中，BFS 使用队列来跟踪待访问的节点。
  4. 消息队列：在分布式系统中，消息队列用于在不同组件之间异步传递消息。

2. 双端队列

        双端队列（Deque）允许在队列的两端进行插入和删除操作，提供了更大的灵活性。

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

typedef struct Node {
    int data;
    struct Node *prev;
    struct Node *next;
} Node;

typedef struct {
    Node *front;
    Node *rear;
} Deque;

void initDeque(Deque *d) {
    d->front = d->rear = NULL;
}

int isEmpty(Deque *d) {
    return d->front == NULL;
}

void insertFront(Deque *d, int value) {
    Node *newNode = (Node*)malloc(sizeof(Node));
    newNode->data = value;
    newNode->prev = NULL;
    newNode->next = d->front;

    if (isEmpty(d)) {
        d->rear = newNode;
    } else {
        d->front->prev = newNode;
    }
    d->front = newNode;
}

void insertRear(Deque *d, int value) {
    Node *newNode = (Node*)malloc(sizeof(Node));
    newNode->data = value;
    newNode->next = NULL;
    newNode->prev = d->rear;

    if (isEmpty(d)) {
        d->front = newNode;
    } else {
        d->rear->next = newNode;
    }
    d->rear = newNode;
}

int deleteFront(Deque *d) {
    if (isEmpty(d)) {
        printf("Deque is empty\n");
        return -1;
    }
    Node *temp = d->front;
    int value = temp->data;
    d->front = d->front->next;
    if (d->front == NULL) {
        d->rear = NULL;
    } else {
        d->front->prev = NULL;
    }
    free(temp);
    return value;
}

int deleteRear(Deque *d) {
    if (isEmpty(d)) {
        printf("Deque is empty\n");
        return -1;
    }
    Node *temp = d->rear;
    int value = temp->data;
    d->rear = d->rear->prev;
    if (d->rear == NULL) {
        d->front = NULL;
    } else {
        d->rear->next = NULL;
    }
    free(temp);
    return value;
}

int main() {
    Deque d;
    initDeque(&d);

    insertFront(&d, 10);
    insertRear(&d, 20);
    insertFront(&d, 5);

    printf("Delete front: %d\n", deleteFront(&d));
    printf("Delete rear: %d\n", deleteRear(&d));

    return 0;
}

/* 运行结果：
Delete front: 5
Delete rear: 20
*/

这个实现使用了双向链表，允许在两端高效地进行插入和删除操作。

应用场景

  1. 工作窃取调度算法：在并行计算中，双端队列用于实现工作窃取算法。
  2. 撤销操作：在文本编辑器中，双端队列可以用来实现撤销和重做功能。
  3. 滑动窗口问题：在处理固定大小的滑动窗口时，双端队列很有用。
  4. 回文检查：双端队列可以有效地用于检查一个字符串是否为回文。

3. 优先队列

        优先队列中，元素被赋予优先级。当访问元素时，具有最高优先级的元素最先删除。这里我们使用最大堆来实现最大优先队列。

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

#define MAX_SIZE 100

typedef struct {
    int heap[MAX_SIZE];
    int size;
} PriorityQueue;

void initPQ(PriorityQueue *pq) {
    pq->size = 0;
}

void swap(int *a, int *b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

void heapifyUp(PriorityQueue *pq, int index) {
    int parent = (index - 1) / 2;
    if (index > 0 && pq->heap[index] > pq->heap[parent]) {
        swap(&pq->heap[index], &pq->heap[parent]);
        heapifyUp(pq, parent);
    }
}

void heapifyDown(PriorityQueue *pq, int index) {
    int largest = index;
    int left = 2 * index + 1;
    int right = 2 * index + 2;

    if (left < pq->size && pq->heap[left] > pq->heap[largest]) {
        largest = left;
    }
    if (right < pq->size && pq->heap[right] > pq->heap[largest]) {
        largest = right;
    }

    if (largest != index) {
        swap(&pq->heap[index], &pq->heap[largest]);
        heapifyDown(pq, largest);
    }
}

void insert(PriorityQueue *pq, int value) {
    if (pq->size >= MAX_SIZE) {
        printf("Priority Queue is full\n");
        return;
    }
    pq->heap[pq->size] = value;
    heapifyUp(pq, pq->size);
    pq->size++;
}

int extractMax(PriorityQueue *pq) {
    if (pq->size <= 0) {
        printf("Priority Queue is empty\n");
        return -1;
    }
    int max = pq->heap[0];
    pq->heap[0] = pq->heap[pq->size - 1];
    pq->size--;
    heapifyDown(pq, 0);
    return max;
}

int main() {
    PriorityQueue pq;
    initPQ(&pq);

    insert(&pq, 10);
    insert(&pq, 30);
    insert(&pq, 20);
    insert(&pq, 5);

    printf("Highest priority: %d\n", extractMax(&pq));
    printf("Next highest priority: %d\n", extractMax(&pq));

    return 0;
}

/* 运行结果：
Highest priority: 30
Next highest priority: 20
*/

        这个优先队列实现使用了最大堆，确保具有最高优先级（这里用数值大小表示优先级）的元素总是在堆顶，可以在O(log n)时间内进行插入和删除操作。

应用场景

  1. 任务调度：在操作系统中，优先队列用于实现基于优先级的进程调度。
  2. Dijkstra最短路径算法：在图算法中，优先队列用于高效地选择下一个要处理的节点。
  3. 事件驱动模拟：在离散事件模拟中，优先队列用于管理按时间顺序排列的事件。
  4. 数据压缩：在Huffman编码等数据压缩算法中，优先队列用于构建Huffman树。
  5. 网络流量管理：在网络路由器中，优先队列用于实现服务质量（QoS）管理。

总结

        队列作为一种基础的数据结构，在计算机科学和软件工程中有着广泛的应用。普通队列、双端队列和优先队列各有其特点和适用场景：

  • 普通队列适用于需要按照先来先服务原则处理数据的场景。
  • 双端队列提供了更灵活的操作，适用于需要在两端进行操作的场景。
  • 优先队列在需要根据优先级处理元素的场景中非常有用。

        理解这些队列类型及其应用场景，可以帮助开发者选择合适的数据结构来解决特定的问题，从而提高程序的效率和可读性。在实际编程中，根据具体需求选择合适的队列类型，将大大提升算法的性能和代码的质量。

Seraphina_Lily
关注
  • 20
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构中的队列_数据结构中的队列类型
culing2941的博客
09-16 1188
数据结构中的队列Queue is an important structure for storing and retrieving data and hence is used extensively among all the data structures. Queue, just like any queue (queues for bus or tickets etc.) follows...
数据结构第五篇——栈和队列
qq_34028001的博客
08-02 608
目录 前言 一、栈的定义和特点 二、栈的逻辑结构以及基本操作 2.1 用抽象数据类型来定义栈的数据结构 2.2 顺序栈的定义及其特点 2.3 顺序存储结构对栈基本操作的实现 2.4 链栈的定义及其特点 2.5 链式存储结构对栈基本操作的实现 三、队列的定义和特点 四、队列的逻辑结构以及基本操作 4.1 用抽象数据类型来定义队列的数据结构 4.2顺序队列的定义及其特点 4.3顺序存储结构对队列基本操作的实现 4.4 链式队列的定义及其特点 4.5 链式存储结构对队列基本操..
数据结构：栈和队列(Stack & Queue)【详解】
热门推荐
UniqueUnit的博客
02-19 23万+
栈和队列知识框架 栈 一、栈的基本概念 1、栈的定义 栈（Stack）：是只允许在一端进行插入或删除的线性表。首先栈是一种线性表，但限定这种线性表只能在某一端进行插入和删除操作。 栈顶（Top）：线性表允许进行插入删除的那一端。 栈底（Bottom）：固定的，不允许进行插入和删除的另一端。 空栈：不含任何元素的空表。 栈又称为先进先出（Last In First Out）的线性表，简称LIFO结构 2、栈的基本操作 InitStack(&S)：初始化一个空栈S。 StackEmpty(S)：
深入理解C语言中的队列：理论与实践
2302_79999839的博客
07-04 937
本文从队列的基本概念出发，详细介绍了队列的性质、实现方法以及在实际项目中的应用。通过理论知识和具体的C语言实现代码，学生党们可以全面掌握队列的使用技巧，为后续的编程学习打下坚实的基础。希望这篇博客对大家有所帮助。如果你有任何问题或建议，欢迎在评论区留言讨论！
C++STL初阶（13）：双端队列deque和优先级队列priority_queue(包含详细计算)
2301_79501467的博客
08-20 649
双开口的含义是：可以在头尾两端进行插入和 删除操作，且时间复杂度为O(1)，与vector比较，头插效率高，不需要搬移元素；与list比较，空间利用率比较高。尽管名字叫双端队列，但是deque和队列FIFO的特性没有太多关系，我们抛开先进先出的特性进行学习。deque是一个顺序容器（sequence container），而不是容器适配器。
数据结构：栈、队列、数组 详解
Cerulea_n的博客
07-01 614
1。
php-pecl-ds：数据结构
02-16
这个扩展是PHP的PECL（PHP Extension Community Library）项目的一部分，由社区开发并维护，为PHP程序员提供了一组C语言实现的高效数据结构。 ### 数据结构概述 1. **ArrayMap**：类似于关联数组，但提供O(1)的...
0854考研初试(自命题) 数据结构强化笔记 Akira37.pdf
04-21
### 数据结构强化笔记知识点概述 #### 一、C语言强化补充笔记 - **0.1 数据类型的长度** 在C语言中，不同数据类型的长度是固定的，这直接影响到内存的使用效率。例如： - `char`: 1 字节 - `short`: 2 字节 -...
浙大数据结构：01-复杂度2 Maximum Subsequence Sum
qq_74924951的博客
09-04 231
【代码】浙大数据结构：01-复杂度2 Maximum Subsequence Sum。
数据结构-顺序表-详解
2401_86587256的博客
08-29 1306
数据结构初阶部分，顺序表的详解。
数据结构的简单认识
最新发布
m0_74445123的博客
09-04 346
在设计算法时，需要考虑算法的时间复杂度和空间复杂度，以确保算法的效率和可行性。不同的数据结构具有不同的特性和操作方式，为算法提供了不同的存储和组织数据的方式。例如，在排序算法中，如果对大量数据进行排序，选择合适的数据结构（如数组或链表）以及相应的排序算法（如快速排序、归并排序等）可以大大提高排序的效率。例如，在图的最短路径问题中，需要使用图这种数据结构来表示问题中的节点和边的关系，然后采用合适的算法（如 Dijkstra 算法或 Floyd 算法）来求解最短路径。反过来，算法的需求也推动了数据结构的发展。
浙大数据结构：01-复杂度1 最大子列和问题
qq_74924951的博客
09-04 152
我们假设最终结果为数组中间的一段，那么左边剩余的部分和右边剩余的部分和一定小于0，对答案没有贡献。使用在线处理，遍历数组，如果当前数组和小于0则抛弃，每次更新最大值。
【数据结构】二叉树的链式结构，二叉树的遍历，求节点个数以及高度
林宇恒的博客
09-02 2055
二叉树遍历，节点个数，高度，创建，销毁
二分查找效率提高的思路是什么
2301_80079026的博客
08-30 436
二分查找比如进行了n次，最后找到一个元素，从后往前，1乘以2就是上次二分查找所剩下的元素，以此类推，进行了n次，就是总共有2的n次个元素，总元素为m个，要是一个一个查找，则最多为m次，也就是2的n次等于m，效率也就变为了log以2为底m的对数。//这里不用(left+right)/2，防止left+right溢出
--- 数据结构 链表 --- java
hadage233的博客
09-01 260
ListNode类使用static修饰，这样你在外部类不用newmylistnode也能使用，不过其实你不写也没有问题的也能正常实现的，不过加上是一个好的习惯，下面的图是java自己实现的链表的构造方法。链表是通过将一个一个储存数据的节点（对象）连起来（通过记录下他们的地址），这些数据在逻辑上就是线性的，但在物理上不是，因为地址是随机的。这样增删查改就完成了，但这个仅仅只是开始，还可实现指定位置的插入，指定值的删除，删除所有链表中存在的指定值，查找该值并返回该节点等等。head是储存链表的头一个节点。
数据结构-栈、队列-详解
2401_86587256的博客
09-04 964
数据结构初阶部分，栈和队列的详解
【数据结构】-----哈希
m0_73470633的博客
08-29 1894
一文看懂哈希结构！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值