C语言实现堆（优先队列）详解

一、堆与优先队列简介

堆（Heap）是一种特殊的完全二叉树结构，满足任意节点的值都大于等于（或小于等于）其子节点的值。本文实现的是最大堆（大根堆）。优先队列是堆的典型应用，支持以下两种核心操作：

• 插入元素：时间复杂度O(logn)

• 弹出最大值：时间复杂度O(logn)

源代码：

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdlib.h>
#include <time.h>#define cmp >
#define ROOT 1
#define FATHER(i) ((i) / 2)
#define LEFT(i)   ((i) * 2)
#define RIGHT(i)  ((i) * 2 + 1)
#define swap(a, b) { \printf("swap(%d, %d)\n", a, b); \int __c = (a); \(a) = (b); \(b) = __c; \
}typedef struct PriorityQueue {int* __data, * data;int size, n;
} PriorityQueue;PriorityQueue* initPQ(int size) {PriorityQueue* p = (PriorityQueue*)malloc(sizeof(PriorityQueue));p->__data = (int*)malloc(sizeof(int) * size);p->data = p->__data - ROOT;p->size = size;p->n = 0;return p;
}int empty(PriorityQueue* p) {return p->n == 0;
}
int full(PriorityQueue* p) {return p->n == p->size;
}
int top(PriorityQueue* p) {return p->data[ROOT];
}void up_update(int* data, int i) {printf("\nUP update : %d\n", data[i]);while (i > ROOT && data[i] cmp data[FATHER(i)]) {swap(data[i], data[FATHER(i)]);i = FATHER(i);}printf("\n");return;
}void down_update(int* data, int i, int n) {printf("\ndown update : %d\n", data[i]);while (LEFT(i) <= n) {int ind = i, l = LEFT(i), r = RIGHT(i);if (data[l] cmp data[ind]) ind = l;if (r <= n && data[r] cmp data[ind]) ind = r;if (ind == i) break;swap(data[i], data[ind]);i = ind;}printf("\n");return;
}int push(PriorityQueue* p, int x) {if (full(p)) return 0;p->n += 1;p->data[p->n] = x;up_update(p->data, p->n);return 1;
}int pop(PriorityQueue* p) {if (empty(p)) return 0;p->data[ROOT] = p->data[p->n];p->n -= 1;down_update(p->data, ROOT, p->n);return 1;
}void clearPQ(PriorityQueue* p) {if (p == NULL) return;free(p->__data);free(p);return;
}void output(PriorityQueue* p) {printf("PQ(%d) : ", p->n);for (int i = 1; i <= p->n; i++) {printf("%d ", p->data[i]);}printf("\n");return;
}int main() {int op, x;
#define MAX_OP 100PriorityQueue* p = initPQ(MAX_OP);while (~scanf("%d", &op)) {if (op == 1) {scanf("%d", &x);printf("insert %d to priority_queue : \n", x);push(p, x); // pushoutput(p);}else {printf("pop : %d\n", top(p));pop(p);     // popoutput(p);}}clearPQ(p);return 0;
}

二、核心代码结构解析

2.1 数据结构定义

c

typedef struct PriorityQueue {int* __data;    // 数据存储空间int* data;       // 指向__data[1]的指针int size;        // 最大容量int n;           // 当前元素个数
} PriorityQueue;

使用动态数组实现堆，data指针指向__data[1]的位置，使得数组下标从1开始计算，便于父子节点访问。

2.2 关键宏定义

c

#define cmp >        // 定义比较符号实现最大堆
#define ROOT 1       // 根节点下标
#define FATHER(i) ((i)/2)
#define LEFT(i)  ((i)*2)
#define RIGHT(i) ((i)*2+1)

通过修改cmp宏可以快速实现最小堆。三个宏定义简化了父子节点的位置计算。

2.3 堆的初始化

c

PriorityQueue* initPQ(int size) {PriorityQueue* p = (PriorityQueue*)malloc(sizeof(PriorityQueue));p->__data = (int*)malloc(sizeof(int)*size);p->data = p->__data - ROOT; // 调整指针偏移p->size = size;p->n = 0;return p;
}

data指针指向__data[1]的巧妙设计，使得所有元素从下标1开始存储。

三、核心操作实现

3.1 插入元素（上浮调整）

c

void up_update(int* data, int i) {while(i > ROOT && data[i] cmp data[FATHER(i)]) {swap(data[i], data[FATHER(i)]);i = FATHER(i);}
}int push(PriorityQueue* p, int x) {if(full(p)) return 0;p->data[++p->n] = x; // 插入到末尾up_update(p->data, p->n);return 1;
}

插入流程：

1. 将新元素放入数组末尾

2. 自底向上与父节点比较

3. 若大于父节点则交换位置

4. 重复直到满足堆性质

3.2 弹出元素（下沉调整）

c

void down_update(int* data, int i, int n) {while(LEFT(i) <= n) {int ind = i, l = LEFT(i), r = RIGHT(i);if(data[l] cmp data[ind]) ind = l;if(r <= n && data[r] cmp data[ind]) ind = r;if(ind == i) break;swap(data[i], data[ind]);i = ind;}
}int pop(PriorityQueue* p) {if(empty(p)) return 0;p->data[ROOT] = p->data[p->n--]; // 末尾元素覆盖根节点down_update(p->data, ROOT, p->n);return 1;
}

删除流程：

1. 用最后一个元素覆盖根节点

2. 自顶向下与子节点比较

3. 与较大的子节点交换位置

4. 重复直到满足堆性质

四、使用示例

c

int main() {PriorityQueue* p = initPQ(10);// 插入元素测试push(p, 5); // [5]push(p, 3); // [5,3]push(p, 8); // [8,3,5]// 弹出测试while(!empty(p)) {printf("Current max: %d\n", top(p));pop(p);}clearPQ(p);return 0;
}

输出结果：

Current max: 8
Current max: 5
Current max: 3

五、完整代码说明

完整代码实现了以下功能：

1. 堆的初始化与销毁

2. 元素插入与上浮调整

3. 最大值弹出与下沉调整

4. 堆空/满状态判断

5. 调试打印交换过程

通过swap宏中的printf可以观察元素调整过程，实际使用时可移除调试输出。

六、应用场景

优先队列常用于：

• 任务调度系统

• 实时计算最大值场景

• 图算法（Dijkstra算法等）

• 合并K个有序链表

该实现的时间复杂度：

• 插入操作：O(logn)

• 删除操作：O(logn)

• 获取最大值：O(1)

注：代码出自B站海贼胡船长