【Java】十大排序算法之堆排序

堆排序

原数组：91, 60, 96, 13, 35, 65, 46, 65, 10, 30, 20, 31, 77, 81, 22

第一步：将数组调整成大顶堆（先按顺序排，之后再进行交换变成大顶堆）

步骤一

步骤二

步骤三

步骤四（已调整成大顶堆）

第二步：将大堆顶堆顶（96）拿出为最大值（将其作为已经分组好的部分，然后长度减一），将堆底（22）放到堆顶的位置，再进行调整为大顶堆，重复操作到全部排序完为止

步骤五

步骤六

步骤七

import java.util.Arrays;

public class HeapSortTest{

    public static void main(String[] args) {
        int[] arr = {91, 60, 96, 13, 35, 65, 46, 65, 10, 30, 20, 31, 77, 81, 22};
        int[] sort = sort(arr);
        System.out.println(Arrays.toString(sort));
    }

    public static int[] sort(int[] sourceArray) {
        int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);

        int length = arr.length;

        // 构建大根堆
        buildMaxHeap(arr, length);

        for (int i = length - 1; i > 0; i--) {
            // 将最后的叶子节点和顶部做交换，因为顶部是最大值，所以放到最后
            swap(arr, 0, i);
            // 因为最后变成是最大值，所以不需要处理，即长度减一
            length--;
            // 调整成大根堆，即顶部为最大值
            heapify(arr, 0, length);
        }
        return arr;
    }

    public static void buildMaxHeap(int[] arr, int length) {
        // 取得最大的父节点，循环到最小父节点
        for (int i = (int) Math.floor(length / 2); i >= 0; i--) {
            // 父节点和其叶子节点作比较，把值大的与父节点做交换
            heapify(arr, i, length);
        }
    }

    public static void heapify(int[] arr, int i, int length) {
        int left = 2 * i + 1;
        int right = 2 * i + 2;
        int largest = i;

        // 左叶子节点大于父节点
        if (left < length && arr[left] > arr[largest]) {
            largest = left;
        }

        // 右叶子节点大于父节点
        if (right < length && arr[right] > arr[largest]) {
            largest = right;
        }

        // 不相等则说明父节点有做修改
        if (largest != i) {
            // 把左右叶子节点值大的与父节点进行交换
            swap(arr, i ,largest);
            // 如果交换过后largest作为父节点，下面如果还有左右叶子节点的话再进行比较交换操作，直到将堆调整到有序)
            heapify(arr, largest, length);
        }
    }

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