排序基础算法（一）—— 堆排序

---

前言

堆排序是一种树形选择排序，在排序过程中，将待排序的记录r[1…n]看成是一棵完全二叉树的顺序存储结构，利用完全二叉树根结点和叶子结点之间的内在关系，在当前无序的序列中选择关键字最大（或最小）的记录

1.完全二叉树

若设二叉树的深度为h ，除第 h 层外， 其它各层 1～(h-1) 的结点数都达到最大个数(即1~(h-1)层为一个满二叉树) ，第 h 层所有的结点都连续集中在最左边，这就是完全二叉树。通俗来说是：

• 二叉树的根结点是满的
• 二叉树的叶子结点只存在最底层或次底层，并且叶子结点集中在左边

---

2.大根堆和小根堆

大根堆：在一棵完全二叉树中，任何一个根结点的值都不小于其叶子结点的值。

小根堆：在一棵完全二叉树中，任何一个根结点的值都不大于其叶子结点的值。

---

3.堆排序原理

根据大根堆和小根堆的特点将当前无序的序列转变成局部有序的序列，交换r[1]和r[n]，在将r[1…n-1]重新进行调整，重复相同操作，循环(n - 1)次,直到r[1]和r[2]为止，得到一个有序的序列。

排序最后结果是顺序要用大根堆，倒序则用小根堆

在交换r[1]和r[n]前，需要解决两个问题：

• 建初堆：如何将一个无序序列建成一个堆？
• 调整堆：去掉堆顶元素，把堆顶元素从r[1]变成r[n]后，如何调整剩下的元素成为一个新的堆？

---

一、调整堆

筛选法：通过根结点和其叶子结点进行比较将较小（大）的关键字逐层筛下去，而将较大（小）的关键字逐层筛选上来。

以建大根堆为例：
假设r[s+1…m]已经是堆的情况下，通过该方法将r[s…m]调整为以r[s]为根的堆，算法实现如下：

算法步骤

• 从r[2s]和r[2s+1]中选择关键字的较大者，假设r[2s]的关键字较大，比较r[s]和r[2s]的关键字
• 1.若r[s].key >= r[2s].key，说明以r[s]为根的子树已经是堆。
  2.若r[s].key < r[2s].key, 交换r[s]和r[2s]。交换后，以r[2s+1]为根的子树依旧是堆，如果r[2s]为根的子树不是堆，则重复上述过程，将以r[2s]为根的子树调整为堆，直到进行到叶子结点为止。

算法描述

void HeapAdjust(List &L, int start, int end) {
    sr = L.r[start];

    for (i = 2 * start; i <= end; i *= 2) {
        if (i < end && L.r[i].key < L.r[i + 1].key) ++i;
        if (sr.key >= L.r[i].key) break;
        L.r[start] = L.r[i];
        start = i;
    }

    L.r[start] = sr;
}

---

二、建初堆

要将一个无序序列调整为堆，就要将其对应的完全二叉树中以每一个结点为根的子树都调整为堆。在完全二叉树中，所有序号大于[n/2]的结点是叶子，因此以这些结点为根的子树均是堆，所以用筛选法从最后一个分支结点[n/2]开始，依次将序号为[n/2],[n/2]-1…,1的结点作为根的子树都调整为堆即可。

算法步骤

对于无序序列r[1…n],从 i = n / 2开始，反复调用筛选法HeapAdjust(L, start, end)，依次将以r[i],r[i-1],…,r[1]为根的子树调整为堆。

算法描述

void CreatHeap(List &L) {
    end = L.length;

    for (start = end / 2; i > 0; --i) {
        HeapAdjust(L, start, end);
    }
}

---

三、堆排序算法的实现

通过上述描述，可知堆排序就是将无序序列建成初堆之后，反复进行排序和堆调整。以下就是堆排序算法的实现：

算法描述

void HeapSort(List &L) {
    CreatHeap(L);

    for (i = L.length; i > 1; --i) {
        tmp = L.r[1];
        L.r[1] = L.r[i];
        L.r[i] = tmp;
        HeapAdjust(L, 1, i - 1);
    }
}

算法分析

时间复杂度
堆排序的运行时间主要耗费在建初堆和调整堆是进行的反复“筛选”上面，其时间复杂度为O(NlogN)
空间复杂度
只需要一个记录大小供交换的辅助存储空间，所以空间复杂度为O(1)

算法特点

• 是不稳定排序
• 只能用于顺序结构，不能用于链式结构
• 初建堆需要次数较多，因此记录数较小时不宜采用，当记录数较多时较为高效

Java代码

import java.util.Arrays;

/**
 * @ProjectName HeapSort
 * @ClassName HeapSort
 * @Description TODO
 * @Author Lyn
 * @Date 2021/4/10 20:32
 * @Version 1.0
 * @Function HeapSort
 */

public class HeapSort {

    public static void main(String[] args) {

        int[] nums = new int[]{9, 6, 8, 5, 2, 4, 3, 1, 7};
        heapSort(nums);

        System.out.println(Arrays.toString(nums));
    }

    public static void createHeap(int[] nums) {
        int end = nums.length;

        for (int i = end / 2 - 1; i >= 0; i --) {
            heapAdjust(nums, i, end - 1);
        }
    }

    public static void heapAdjust(int[] nums, int start, int end) {
        for (int i = 2 * start + 1; i <= end; i = 2 * i + 1) {
            if (i < end && nums[i] < nums[i + 1]) i += 1;
            if (nums[start] >= nums[i]) break;
            int tmp = nums[start];
            nums[start] = nums[i];
            nums[i] = tmp;
            start = i;
        }
    }

    public static void heapSort(int[] nums) {
        createHeap(nums);

        for (int i = nums.length - 1; i >= 1; i--) {
            int tmp = nums[0];
            nums[0] = nums[i];
            nums[i] = tmp;

            heapAdjust(nums, 0, i - 1);
        }
    }

}