堆排序 Java

堆排序的原理

基本原理也是选择排序，只是不在使用遍历的方式查找无序区间的最大的数，而是通过堆来选择无序区间的最大的 数。
注意: 排升序要建大堆;排降序要建小堆。

堆排序实现

升序为例

public class heapSort {
    public static void heapSort(int[] array) {
    	//根据给的数组来创建堆
        creatHeap(array);
        //循环交换第一个元素倒数第i个元素
        //并且将新的顺序进行调整以满足堆的性质
        for (int i = 0; i < array.length; i++) {
            swap(array, 0, array.length - 1 - i);
            shiftDown(array, array.length - 1- i, 0);
        }
    }
	
	//创建堆
    private static void creatHeap(int[] array) {
        for (int i = (array.length - 1) / 2; i >= 0; i--) {
            shiftDown(array, array.length, i);
        }
    }

	//向下调整
    private static void shiftDown(int[] array, int size, int index) {
        int parent = index;
        int child = parent * 2 + 1;
        while (child < size) {
            if (child + 1 < size && array[child] < array[child + 1]) {
                child = child + 1;
            }
            if (array[parent] < array[child]) {
                swap(array, parent, child);
            } else {
                break;
            }
            parent = child;
            child = parent * 2 + 1;
        }
    }

    private static void swap(int[] array, int x, int y) {
        int temp = array[x];
        array[x] = array[y];
        array[y] = temp;
    }

    public static void main(String[] args) {
        int[] array = {9, 5, 2, 7, 3, 6, 8, 1};
        heapSort(array);
        System.out.println(Arrays.toString(array));
    }
}

性能分析

时间复杂度	空间复杂度
O(n * log(n))	O(1)
数据不敏感	数据不敏感

稳定性：不稳定