堆排序 Java

堆排序是一种基于比较的排序算法，其时间复杂度为 O(n log n)。该算法使用堆数据结构进行排序，通常采用数组来实现堆。

堆排序的实现步骤

1. 构建最大堆或最小堆
   • 最大堆：父节点的值大于或等于其左右子节点的值
   • 最小堆：父节点的值小于或等于其左右子节点的值
2. 交换堆顶元素和堆底元素
3. 忽略堆底元素，将剩余元素重新构建堆
4. 重复步骤 2、3 直到所有元素有序

堆排序的代码实现

public class HeapSort {
    public static void sort(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--) {
            int temp = arr[0];
            arr[0] = arr[i];
            arr[i] = temp;

            heapify(arr, i, 0);
        }
    }

    // 构建堆
    public static void heapify(int[] arr, int n, int i) {
        int largest = i;  // 堆顶元素
        int l = 2 * i + 1;  // 左子节点
        int r = 2 * i + 2;  // 右子节点

        // 找出左右子节点中的最大值
        if (l < n && arr[l] > arr[largest])
            largest = l;
        if (r < n && arr[r] > arr[largest])
            largest = r;

        // 如果最大值不是堆顶元素，则交换堆顶元素和最大值，并重新构建堆
        if (largest != i) {
            int temp = arr[i];
            arr[i] = arr[largest];
            arr[largest] = temp;

            heapify(arr, n, largest);
        }
    }
}

堆排序的时间复杂度

堆排序的时间复杂度为 O(n log n)，其中 n 表示元素个数。

堆排序的优缺点

优点

1. 时间复杂度为 O(n log n)，效率较高；
2. 不占用额外的内存空间，空间复杂度为 O(1)。

缺点

1. 对于小规模数据排序效率不高；
2. 不稳定，可能改变相同元素的相对位置。

堆排序的应用场景

堆排序适用于数据规模较大的情况，是一种高效的排序算法。在实际开发中，往往被用于需要排序的数据量比较大的场景。