01_06_堆排序（Heap Sort）

堆排序（Heap Sort）

堆排序（Heap Sort）介绍：

是一种基于二叉堆数据结构的排序算法。它通过将待排序的序列构建成一个最大堆（或最小堆），然后逐步将堆顶元素与最后一个元素交换，并对剩余元素重新进行堆调整，重复这个过程直到整个序列有序。

堆排序（Heap Sort）原理：

1. 构建最大堆（或最小堆）：将待排序序列构建成一个最大堆（或最小堆）。最大堆的定义是父节点的值大于等于其子节点的值，最小堆的定义是父节点的值小于等于其子节点的值。
2. 交换堆顶元素：将堆顶元素与最后一个元素交换，使得最大（或最小）元素排在序列的末尾。
3. 调整堆：对除最后一个元素之外的剩余元素进行堆调整，使得剩余元素构成一个新的最大堆（或最小堆）。
4. 重复步骤2和步骤3，直到整个序列有序。

Java 代码实现：

package com.algorithm.sort;

/**
 * 堆排序的原理可以描述如下：
 * <p>
 * 1.构建最大堆（或最小堆）：将待排序序列构建成一个最大堆（或最小堆）。最大堆的定义是父节点的值大于等于其子节点的值，最小堆的定义是父节点的值小于等于其子节点的值。
 * 2.交换堆顶元素：将堆顶元素与最后一个元素交换，使得最大（或最小）元素排在序列的末尾。
 * 3.调整堆：对除最后一个元素之外的剩余元素进行堆调整，使得剩余元素构成一个新的最大堆（或最小堆）。
 * 4.重复步骤2和步骤3，直到整个序列有序。
 */

public class HeapSort {

    /**
     * 堆排序算法实现
     *
     * @param arr 待排序数组
     */
    public static void heapSort(int[] arr) {
        int n = arr.length;

        // 构建最大堆
        for (int i = n / 2 - 1; i >= 0; i--) {
            heapify(arr, n, i);
        }

        // 逐步将堆顶元素与最后一个元素交换，并调整堆
        for (int i = n - 1; i > 0; i--) {
            swap(arr, 0, i);
            heapify(arr, i, 0);
        }
    }

    /**
     * 构建最大堆
     *
     * @param arr
     * @param n
     * @param i
     */
    public static void heapify(int[] arr, int n, int i) {
        int largest = i; // 初始化最大元素的索引
        int left = 2 * i + 1; // 左子节点索引
        int right = 2 * i + 2; // 右子节点索引

        // 如果左子节点存在且大于最大元素，则更新最大元素索引
        if (left < n && arr[left] > arr[largest]) {
            largest = left;
        }

        // 如果右子节点存在且大于最大元素，则更新最大元素索引
        if (right < n && arr[right] > arr[largest]) {
            largest = right;
        }

        // 如果最大元素不是当前节点，则交换当前节点与最大元素，并递归调整堆
        if (largest != i) {
            swap(arr, i, largest);
            heapify(arr, n, largest);
        }
    }

    /**
     * 交换元素
     *
     * @param arr 待交换数组
     * @param i   数组下标
     * @param j   数组下标
     */
    public static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

    /**
     * 测试方法
     *
     * @param args todo
     */
    public static void main(String[] args) {
        int[] arr = {64, 34, 25, 12, 22, 11, 90};
        heapSort(arr);
        System.out.println("排序后的数组：");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
}

代码简单解释：

在上述代码中，heapSort 方法接受一个整数数组 arr 作为输入，并调用 heapify 方法构建最大堆，然后通过交换堆顶元素和最后一个元素，并调整堆的方式实现排序。heapify 方法用于调整堆，保持最大堆的性质。

程序执行结果：

排序后的数组：
11 12 22 25 34 64 90 
Process finished with exit code 0

备注：

• 堆排序的时间复杂度为O(nlogn)，它是一种原地排序算法，不需要额外的空间。
• 堆排序在处理大规模数据时具有较好的性能，但不保证稳定性。