堆排序详解：从原理到实现

最新推荐文章于 2025-12-16 14:17:05 发布

原创最新推荐文章于 2025-12-16 14:17:05 发布 · 1k 阅读

20 ·

CC 4.0 BY-SA版权

文章标签：

#算法

1. 堆的基本概念

什么是堆？

堆是一种特殊的完全二叉树，它满足以下性质：

对于大顶堆：每个节点的值都大于或等于其左右子节点的值
对于小顶堆：每个节点的值都小于或等于其左右子节点的值

堆的分类

堆主要分为两种类型：

大顶堆：根节点是所有节点中的最大值，适用于升序排序
小顶堆：根节点是所有节点中的最小值，适用于降序排序

为什么要建堆？

建堆的目的是为了快速获取数据集中的最大值或最小值。堆结构可以在O(1)时间内获取极值，并在O(log n)时间内维护堆的性质，这使得堆在排序和优先级队列等场景中非常高效。

建堆的用途

堆排序：高效的排序算法，时间复杂度为O(n log n)
优先级队列：快速获取和删除最高/最低优先级的元素
解决Top-K问题：快速找出前K个最大或最小的元素
图算法：如Dijkstra算法中使用堆优化

2. 向上调整算法

算法思路

向上调整算法用于在堆中插入新元素时维护堆的性质。当向堆末尾插入新元素后，需要将该元素与其父节点比较，如果违反堆性质则交换，重复此过程直到满足堆性质或到达根节点。

算法实现

//向上调整算法
void AdjustUp(HPDataType* a, int child) {
    assert(a);
    int parent = (child - 1) / 2;
    while (child > 0) {
        if (a[child] > a[parent]) {   // >建立大根堆，<建立小根堆
            Swap(&a[child], &a[parent]);
            child = parent;
            parent = (child - 1) / 2;
        }
        else {
            break;
        }
    }
}

时间复杂度

向上调整算法的时间复杂度为O(log n)，因为最坏情况下需要从叶子节点调整到根节点，而完全二叉树的高度为log₂n。

3. 向下调整算法

算法思路

向下调整算法用于删除堆顶元素后维护堆的性质。当删除堆顶元素后，将最后一个元素移到堆顶，然后将该元素与其较大的子节点比较，如果违反堆性质则交换，重复此过程直到满足堆性质或到达叶子节点。

算法实现

//向下调整算法
void AdjustDown(HPDataType* a, int n, int parent) {
    assert(a);
    int child = parent * 2 + 1;  //找到左孩子结点
    while (child < n) {  //到最后一个结点结束
        //先比较左右孩子，选择较大的（大顶堆）或较小的（小顶堆）
        if (child + 1 < n && a[child] < a[child + 1]) {
            child++;
        }
        // 比较父节点和子节点，大顶堆时如果父节点小于子节点则交换
        if (a[parent] < a[child]) {
            Swap(&a[parent], &a[child]);
            parent = child; //跳到下一层结点比较
            child = parent * 2 + 1; //更新child结点
        }
        else {
            break;
        }
    }
}

时间复杂度

向下调整算法的时间复杂度也是O(log n)，因为最坏情况下需要从根节点调整到叶子节点。

4. 为什么选择向下调整建堆？

从最后一个非叶子节点开始调整的原因

在构建堆时，我们选择从最后一个非叶子节点开始向前依次进行向下调整，这是因为：

叶子节点没有子节点，已经满足堆的性质，不需要调整
完全二叉树中，最后一个非叶子节点的索引为(n-1-1)/2（补充：完全二叉树父亲结点的索引是(孩子结点-1)/2,基于初始索引为0的情况，故最后一个非叶子节点的索引为(n-1-1)/2）

各层节点调整次数分析

假设有一个包含n个节点的完全二叉树，高度为h：

第h层（叶子层）：有2^(h-1)个节点，不需要调整
第h-1层：有2^(h-2)个节点，每个节点最多需要调整1次
第h-2层：有2^(h-3)个节点，每个节点最多需要调整2次
...
第1层（根节点）：有1个节点，最多需要调整h-1次

时间复杂度优势

向下调整建堆的时间复杂度为O(n)，而向上调整建堆的时间复杂度为O(n log n)。这是因为：

越高层的节点数量越少，但需要调整的次数越多
越低层的节点数量越多，但需要调整的次数越少
向下调整建堆充分利用了这一特性，使得总调整次数更少

5. 堆排序算法实现

算法步骤

构建初始堆：将无序数组构建成一个大顶堆（升序排序）
交换堆顶和末尾元素：将最大元素移到最后
调整堆：对前n-1个元素重新调整成大顶堆
重复步骤2-3，直到所有元素有序

算法实现

// 堆排序
void HeapSort(int* a, int n) {
    // 构建初始大顶堆
    for (int i = (n - 1 - 1) / 2; i >= 0; i--) {
        AdjustDown(a, n, i);
    }
    
    // 依次取出堆顶元素并调整
    for (int i = n - 1; i > 0; i--) {
        Swap(&a[0], &a[i]);  // 将堆顶元素（最大值）移到末尾
        AdjustDown(a, i, 0); // 对前i个元素重新调整成大顶堆
    }
}