C语言的优先队列

最新推荐文章于 2025-04-21 22:17:42 发布

卓悠然

最新推荐文章于 2025-04-21 22:17:42 发布

阅读量491

点赞数 3

分类专栏：包罗万象文章标签： golang 开发语言后端

本文链接：https://blog.youkuaiyun.com/2501_91409211/article/details/146704513

版权

包罗万象专栏收录该内容

24 篇文章

订阅专栏

C语言的优先队列详解

引言

优先队列是一种特殊的队列数据结构，其中每个元素都与一个优先级相关联。优先队列中的元素根据其优先级排序，优先级高的元素会比优先级低的元素先被移除或处理。优先队列在计算机科学中有着广泛的应用，包括调度算法、图算法（如Dijkstra算法和A*算法）、事件驱动仿真等。在C语言中，优先队列通常使用堆（Heap）结构来实现，尤其是二叉堆（Binary Heap）。

本文将详细介绍优先队列的基本概念、常见的实现方式、C语言中的具体实现示例，以及优先队列在实际应用中的一些例子。

一、优先队列的基本概念

优先队列是一种抽象数据类型（Abstract Data Type, ADT），它支持以下主要操作：

插入（Insert）：将一个新元素添加到优先队列中。
删除最大元素（Delete-Max） 或 删除最小元素（Delete-Min）：根据优先级删除并返回优先队列中优先级最高（或最低）的元素。
查看最大元素（Peek-Max） 或 查看最小元素（Peek-Min）：返回优先队列中优先级最高（或最低）的元素，但不删除它。

优先队列可以通过不同的数据结构实现，比如线性表、链表、堆等。最常用的是堆结构，因为堆能够保证插入和删除操作的时间复杂度保持在O(log n)。

二、堆的基本知识

堆是一个特殊的完全二叉树，可以分为最大堆和最小堆：

最大堆：每个节点的值都大于或等于其子节点的值。最大堆的根节点包含最大值。
最小堆：每个节点的值都小于或等于其子节点的值。最小堆的根节点包含最小值。

堆通常使用数组表示，给定一个索引为i的节点，它的左子节点索引为2i+1，右子节点索引为2i+2，父节点索引为(i-1)/2。

2.1 堆的基本操作

为了实现优先队列，我们需要对堆进行一些基本操作，主要有以下几种：

插入操作（insert）：将新元素插入到堆中，并调整堆以保持堆的性质。
删除操作（delete）：移除根节点元素（最大或最小），并调整堆以保持堆的性质。
堆化（heapify）：从某个节点开始调整堆的结构，以维护堆的性质。

三、优先队列的实现

接下来，我们将通过C语言实现一个简单的优先队列，使用最大堆作为其底层数据结构。

3.1 数据结构定义

首先，我们需要定义优先队列的数据结构。我们将使用一个数组来存储堆，并定义一个结构体来表示优先队列。

```c

include

// 定义优先队列结构体 typedef struct { int* elements; // 存储堆元素的数组 int size; // 当前堆中元素的个数 int capacity; // 堆的最大容量 } PriorityQueue; ```

3.2 初始化优先队列

我们需要提供一个函数来初始化优先队列，包括分配内存和设置初始值。

c PriorityQueue* createPriorityQueue(int capacity) { PriorityQueue* pq = (PriorityQueue*)malloc(sizeof(PriorityQueue)); pq->elements = (int*)malloc(sizeof(int) * capacity); pq->size = 0; pq->capacity = capacity; return pq; }

3.3 插入元素

插入元素的基本步骤是将新元素添加到数组的末尾，然后通过上浮操作（bubble-up）来调整堆。

```c void insert(PriorityQueue* pq, int value) { if (pq->size >= pq->capacity) { printf("优先队列已满，无法插入新元素。\n"); return; }

pq->elements[pq->size] = value; // 将新元素放入最后
pq->size++; // 增加堆的大小
int index = pq->size - 1; // 新元素的索引

// 上浮调整堆
while (index > 0) {
    int parentIndex = (index - 1) / 2;
    if (pq->elements[parentIndex] >= pq->elements[index]) {
        break; // 堆性质已经满足
    }
    // 交换父节点和当前节点
    int temp = pq->elements[parentIndex];
    pq->elements[parentIndex] = pq->elements[index];
    pq->elements[index] = temp;
    index = parentIndex; // 更新当前索引
}

} ```

3.4 删除最大元素

删除最大元素的基本步骤是将根节点的值与最后一个节点的值交换，然后删除最后一个节点，最后通过下沉操作（bubble-down）来调整堆。

```c int deleteMax(PriorityQueue* pq) { if (pq->size <= 0) { printf("优先队列为空，无法删除最大元素。\n"); return -1; // 表示空队列 }

int maxValue = pq->elements[0]; // 根节点的值
pq->elements[0] = pq->elements[pq->size - 1]; // 将最后一个元素放到根节点
pq->size--; // 减少堆的大小

// 下沉调整堆
int index = 0; // 从根节点开始
while (index < pq->size) {
    int leftChildIndex = 2 * index + 1;
    int rightChildIndex = 2 * index + 2;
    int largestIndex = index;

    // 找到最大的子节点
    if (leftChildIndex < pq->size && pq->elements[leftChildIndex] > pq->elements[largestIndex]) {
        largestIndex = leftChildIndex;
    }
    if (rightChildIndex < pq->size && pq->elements[rightChildIndex] > pq->elements[largestIndex]) {
        largestIndex = rightChildIndex;
    }

    if (largestIndex == index) {
        break; // 堆性质已经满足
    }

    // 交换当前节点和最大子节点
    int temp = pq->elements[index];
    pq->elements[index] = pq->elements[largestIndex];
    pq->elements[largestIndex] = temp;
    index = largestIndex; // 更新当前索引
}

return maxValue; // 返回删除的最大值

} ```

3.5 查看最大元素

查看最大元素很简单，只需返回根节点的值。

c int peekMax(PriorityQueue* pq) { if (pq->size <= 0) { printf("优先队列为空，无法查看最大元素。\n"); return -1; // 表示空队列 } return pq->elements[0]; }

3.6 销毁优先队列

最后，我们需要一个函数来销毁优先队列并释放内存。

c void destroyPriorityQueue(PriorityQueue* pq) { free(pq->elements); free(pq); }

3.7 示例代码

结合上述所有实现，我们可以写一个完整的优先队列示例代码。

```c

include

typedef struct { int* elements; int size; int capacity; } PriorityQueue;

PriorityQueue createPriorityQueue(int capacity) { PriorityQueue pq = (PriorityQueue)malloc(sizeof(PriorityQueue)); pq->elements = (int)malloc(sizeof(int) * capacity); pq->size = 0; pq->capacity = capacity; return pq; }

void insert(PriorityQueue* pq, int value) { if (pq->size >= pq->capacity) { printf("优先队列已满，无法插入新元素。\n"); return; }

pq->elements[pq->size] = value;
pq->size++;
int index = pq->size - 1;

while (index > 0) {
    int parentIndex = (index - 1) / 2;
    if (pq->elements[parentIndex] >= pq->elements[index]) {
        break;
    }

    int temp = pq->elements[parentIndex];
    pq->elements[parentIndex] = pq->elements[index];
    pq->elements[index] = temp;
    index = parentIndex;
}

}

int deleteMax(PriorityQueue* pq) { if (pq->size <= 0) { printf("优先队列为空，无法删除最大元素。\n"); return -1; }

int maxValue = pq->elements[0];
pq->elements[0] = pq->elements[pq->size - 1];
pq->size--;

int index = 0;
while (index < pq->size) {
    int leftChildIndex = 2 * index + 1;
    int rightChildIndex = 2 * index + 2;
    int largestIndex = index;

    if (leftChildIndex < pq->size && pq->elements[leftChildIndex] > pq->elements[largestIndex]) {
        largestIndex = leftChildIndex;
    }
    if (rightChildIndex < pq->size && pq->elements[rightChildIndex] > pq->elements[largestIndex]) {
        largestIndex = rightChildIndex;
    }

    if (largestIndex == index) {
        break;
    }

    int temp = pq->elements[index];
    pq->elements[index] = pq->elements[largestIndex];
    pq->elements[largestIndex] = temp;
    index = largestIndex;
}

return maxValue;

}

int peekMax(PriorityQueue* pq) { if (pq->size <= 0) { printf("优先队列为空，无法查看最大元素。\n"); return -1; } return pq->elements[0]; }

void destroyPriorityQueue(PriorityQueue* pq) { free(pq->elements); free(pq); }

int main() { PriorityQueue* pq = createPriorityQueue(10);

insert(pq, 30);
insert(pq, 20);
insert(pq, 50);
insert(pq, 40);

printf("最大元素: %d\n", peekMax(pq)); // 输出最大元素

printf("删除最大元素: %d\n", deleteMax(pq));
printf("删除最大元素: %d\n", deleteMax(pq));

destroyPriorityQueue(pq); // 释放内存
return 0;

} ```