算法-11-堆排序

十一、堆排序（Heap Sort）

1、概念

使用堆数据结构，而实现的一种排序。

分为大顶堆和小顶堆两种：

• 大顶堆，它是一棵完全二叉树，每个节点的值都大于或等于其左右子节点的值，但是没有规定左子节点的值和右子节点的值的大小关系。正序使用大顶堆。

  array[i] >= array[i * 2 + 1] && array[i] >= array[i * 2 + 2]

• 小顶堆：它是一棵完全二叉树，每个节点的值都小于或等于其左右子节点的值，但是没有规定左子节点的值和右子节点的值的带下关系。倒序使用小顶堆。

  array[i] <= array[i * 2 + 1] && array[i] <= array[i * 2 + 2]

将待排序序列构造成一个大顶堆后，根节点的值就是最大值，将其与尾索引值进行交换，这样尾索引值就是最大值。再将剩余元素重新构造成一个大顶堆，反复构造和交换，实现最终排序。

堆排序属于选择排序的一种。

2、过程

1. 首先创建一个方法，用于将排序序列构建成一个大顶堆（正序）。循环比较当前节点（父节点）的值与其左右子节点的值的大小，并将较大值赋值给当前节点，并更新当前节点的索引位置。比较完成后，需要重置初始比较节点的值。
2. 先将排序序列的前半部分(排序序列长度 / 2 - 1)到首第一个索引位置，进行大顶堆的创建。这样可以确定较大值都在排序序列的前半部分。
3. 最后再从排序序列的尾向首第二个索引位置，依次进行大顶堆的构造、比较节点值与第一个索引位置值交换。实现最终排序。

3、示例

正序

public void heapSort(int[] array) {
    int len = array.length;
    for (int i = len / 2 - 1; i >= 0; i--) {
        adjustHeap(array, i, len);
    }

    int temp;
    for (int j = len - 1; j > 0; j--) {
        temp = array[j];
        array[j] = array[0];
        array[0] = temp;
        adjustHeap(array, 0, j);
    }
}

private void adjustHeap(int[] array, int i, int length) {
    int temp = array[i];
    for (int j = i * 2 + 1; j < length; j = j * 2 + 1) {
        if ((j + 1) < length && array[j] < array[j + 1]) { // 左子节点小于右子节点
            j++; // 指向右子节点
        }
        if (array[j] > temp) { // 子节点大于父节点
            array[i] = array[j]; // 将子节点的值赋值给父节点
            i = j; // 更新父节点索引
        } else {
            break;
        }
    }
    array[i] = temp; // 还原初始节点值
}

倒序

public void heapSort(int[] array) {
    int len = array.length;
    for (int i = len / 2 - 1; i >= 0; i--) {
        adjustHeap(array, i, len);
    }

    int temp;
    for (int j = len - 1; j > 0; j--) {
        temp = array[j];
        array[j] = array[0];
        array[0] = temp;
        adjustHeap(array, 0, j);
    }
}

private void adjustHeap(int[] array, int i, int length) {
    int temp = array[i];
    for (int j = i * 2 + 1; j < length; j = j * 2 + 1) {
        if ((j + 1) < length && array[j] > array[j + 1]) { // 倒序
            j++;
        }
        if (array[j] < temp) { // 倒序
            array[i] = array[j];
            i = j;
        } else {
            break;
        }
    }
    array[i] = temp;
}

4、性能

• 时间复杂度：平均时间复杂度O(nlog₂n)，最坏时间复杂度O(nlog₂n)
• 空间复杂度：O(1)
• 稳定性：不稳定（a=b，排序前a在b的前面，排序后a不一定还在b的前面）