减治算法——堆排序

java代码

堆排序是一种基于二叉堆的排序算法，它的时间复杂度为O(nlogn)，具体步骤如下：

1. 将记录序列构建成一个大根堆（或小根堆），保证每个父节点都比其子节点大（或小）。
2. 取出堆顶元素（即最大值或最小值），将其与堆底元素交换位置，并将堆底元素从堆中删除。
3. 对剩余的n-1个元素重新构建堆，重复步骤2直到所有元素都有序。

Java代码如下：

import java.util.Arrays;

public class HeapSort {

    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操作
            heapify(arr, i, 0);
        }
    }

    private 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;
        }

        // 如果最大值不是父节点，则交换它和父节点的位置，并对交换后的子节点再进行heapify操作
        if (largest != i) {
            swap(arr, i, largest);
            heapify(arr, n, largest);
        }
    }

    private static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

    public static void main(String[] args) {
        int[] arr = {5, 2, 8, 3, 6, 9};
        System.out.println("排序前：" + Arrays.toString(arr));
        heapSort(arr);
        System.out.println("堆排序后：" + Arrays.toString(arr));
    }
}

在堆排序的过程中，需要进行n次heapify操作，每次操作的时间复杂度为O(logn)，因此堆排序的总时间复杂度为O(nlogn)。

以上代码输出结果为：

排序前：[5, 2, 8, 3, 6, 9]
堆排序后：[2, 3, 5, 6, 8, 9]

伪代码

函数 heapSort(整数数组 arr):
    定义 n 等于 arr.length

    // 构建大根堆
    从 (n/2)-1 循环到 0，定义变量 i：
        调用 heapify 函数传入参数 arr、n 和 i 进行heapify操作

    // 依次取出堆顶元素并重新构建堆
    从 n-1 循环到 1，定义变量 i：
        交换 arr[0] 和 arr[i] 的值
        调用 heapify 函数传入参数 arr、i 和 0 进行heapify操作

函数 heapify(整数数组 arr, 整数 n, 整数 i):
    定义 largest 等于 i
    定义左子节点 left 等于 2*i+1
    定义右子节点 right 等于 2*i+2

    // 找出左右子节点中的最大值
    如果 left < n 并且 arr[left] > arr[largest]，则将 largest 赋值为 left
    如果 right < n 并且 arr[right] > arr[largest]，则将 largest 赋值为 right

    // 如果最大值不是父节点，则交换它和父节点的位置，并对交换后的子节点再进行heapify操作
    如果 largest 不等于 i，则交换 arr[i] 和 arr[largest] 的值
    调用 heapify 函数传入参数 arr、n 和 largest 进行heapify操作

函数 swap(整数数组 arr, 整数 i, 整数 j):
    定义临时变量 tmp 为 arr[i]
    将 arr[i] 赋值为 arr[j]
    将 arr[j] 赋值为 tmp

主函数 HeapSortTest：
    定义整数数组 arr 并赋值为 {5, 2, 8, 3, 6, 9}
    输出 "排序前：" 和 Arrays.toString(arr)
    调用 heapSort 函数传入参数 arr 进行堆排序
    输出 "堆排序后：" 和 Arrays.toString(arr)