记排序算法（7）- 堆排序

算法描述

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

• 将初始待排序关键字序列(R1,R2….Rn)构建成大顶堆，此堆为初始的无序区；
• 将堆顶元素R[1]与最后一个元素R[n]交换，此时得到新的无序区(R1,R2,……Rn-1)和新的有序区(Rn),且满足R[1,2…n-1]<=R[n]；
• 由于交换后新的堆顶R[1]可能违反堆的性质，因此需要对当前无序区(R1,R2,……Rn-1)调整为新堆，然后再次将R[1]与无序区最后一个元素交换，得到新的无序区(R1,R2….Rn-2)和新的有序区(Rn-1,Rn)。不断重复此过程直到有序区的元素个数为n-1，则整个排序过程完成。

动画展示

代码实现

public class HeapSort {
    public static void main(String[] args) {
        int length = CommonStant.ARR.length;
        buildMaxHeap(CommonStant.ARR, length);

        for (int i = length - 1; i >0; i--) {
            swap(CommonStant.ARR, 0, i);
            heapify(CommonStant.ARR,0, i);
        }
        Arrays.stream(CommonStant.ARR).forEach(System.out::println);
    }

    private static void buildMaxHeap(int[] arr, int len){
        for (int i = len / 2; i >= 0; i--) {
            heapify(arr, i, len);
        }
    }
    private static void heapify(int[] arr, int i, int len){
        int left = i*2+1;
        int right = i*2 + 2;
        int largest = i;

        if (left < len && arr[left] > arr[largest]){
            largest = left;
        }

        if (right < len && arr[right] > arr[largest]){
            largest = right;
        }

        if(largest != i){
            swap(arr, largest, i);
            heapify(arr, largest, len);
        }

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

总结

稳定性：算法不稳定，归并排序在排序前后两个相等的数相对位置发生改变。
时间复杂度：O(nlogn)，最好情况O(nlogn), 最坏情况O(nlogn)。
空间复杂度：O(1)，不需要额外的变量进行存储。