堆排序（Java）

一、堆排序

堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。堆排序可以说是一种利用堆的概念来排序的选择排序。分为两种方法：

1. 大顶堆：每个节点的值都大于或等于其子节点的值，在堆排序算法中用于升序排列；
2. 小顶堆：每个节点的值都小于或等于其子节点的值，在堆排序算法中用于降序排列；
   堆排序的平均时间复杂度为 Ο(nlogn)。

二、代码&注释

import java.util.Arrays;

/**
 * @author: pikachu
 * @description: 堆排序
 * @date: 2022/8/14 20:21
 */
public class HeapSort {
    public static void sort(int[] a) {
        int temp;
        // 从最后一个非叶子节点开始，直到根节点，构建大根堆
        for (int i = a.length / 2 - 1; i >= 0; i--) {
            build(a, i, a.length - 1);
        }
        // 交换首尾节点后，以a[0]为根节点重建大根堆
        for (int i = a.length - 1; i > 0; i--) {
            temp = a[0];
            a[0] = a[i];
            a[i] = temp;

//            for (int j = 0; j <= i; j++) {
//                System.out.print(a[j]+" ,");
//            }
//            System.out.println();

            build(a, 0, i - 1);
        }
    }

    /**
     * Desc:    将以root为根节点的子树构建大顶堆
     *
     * @param a    待排序数组
     * @param root 以root待调整数的根节点
     * @param end  待调整的节点数(即待确定的最后一个节点的坐标)
     * @author pikachu
     */
    private static void build(int[] a, int root, int end) {
        int right, k, temp; //k:MAX( a[left] , a[right] )
        //计算root时，root为最后一个含子树的节点，指向需要调整的子树,令 i 从root 的左子树开始赋值
        for (int i = root * 2 + 1; i <= end; i = root * 2 + 1) {
            k = i;
            right = i + 1;
            if (right <= end && a[right] > a[i]) {
                k = right;
            }
            if (a[root] < a[k]) {
                temp = a[root];
                a[root] = a[k];
                a[k] = temp;
                // 若发生交换， i 需要指向与其交换的子节点，再次循环判断该子节点的子树是否需要重新构建
                root = k;
            }
            //  已满足大根堆，退出
            //  在第一次构建大根堆时自下而上，
            //  因此在重新构建时，若该节点与左右节点满足大根堆，
            //  那么以该节点的子树已满足大根堆
            else {
                // 对于     6 (root)  的子树已满足大根堆，若不退出循环，root始终指向6，k始终指向左子节点4
                //        /  \
                //       4    4
                return;
            }

        }
    }

    public static void main(String[] args) {
//        int[] arr = {3, 3, 6, 6, 2, 0, 9, 4, 4, 8};
//        int[] arr1 = Arrays.copyOfRange(arr, 0, arr.length);
        int n = 1000000;
        int[] arr = new int[n];
        int[] arr1 = new int[n];
        for (int i = 0; i < n; i++) {
            arr[i] = (int) (Math.random() * n);
            arr1[i] = arr[i];
        }

//        System.out.println("排序前:" + Arrays.toString(arr));
        long start = System.currentTimeMillis();
        HeapSort.sort(arr);
        long end = System.currentTimeMillis();
//        System.out.println("排序后:" + Arrays.toString(arr));
        System.out.println(n / 10000 + "w条数据" + "HeapSort耗时:" + (end - start) + "毫秒");

        long start1 = System.currentTimeMillis();
        Arrays.sort(arr1);
        long end1 = System.currentTimeMillis();
        System.out.println(n / 10000 + "w条数据" + "Arrays.sort耗时:" + (end1 - start1) + "毫秒");
        System.out.println("Arrays.equals(arr, arr1) = " + Arrays.equals(arr, arr1));
    }
}