排序算法——堆排序（java语言描述）

排序法	平均时间复杂度	最差时间复杂度	空间复杂度	是否稳定
堆排序	O(n*logn)	O(n*logn)	O(1)	不稳定

---

public class HeapSort {
    private static int heapSize;//记录当前堆大小
    public static void main(String[] args) {
        HeapSort heapSort = new HeapSort();
        int[] array = {4,1,3,2,16,9,10,14,8,7};
        heapSort.doHeapSort(array);
        for(int i = 0; i < array.length; i++){
            System.out.print(array[i] + " ");
        }
    }
    /*堆排序：堆中索引最大的结点n的数值与堆根节点的数值交换，并从堆中去除n节点，此时堆的根节点违背最大堆的性质，因此对其执行maxHeapify方法。循环执行该操作，最终会得到有序数组*/
    private void doHeapSort(int[] array) {
        buildMaxHeap(array);
        for(int i = array.length - 1; i > 0; i--) {
            exchange(array, 0, i);
            heapSize--;
            maxHeapify(array, 0);
        }

    }
    /*建堆（最大堆）：通过自底向上的方式让每一个非叶子节点执行maxHeapify方法将数组构建为最大堆。*/
    private void buildMaxHeap(int array[]) {
        heapSize = array.length;
        for(int i = array.length/2 - 1; i >= 0; i--) {
            maxHeapify(array, i);
        }
    }
    /*堆维护：传入数组array以及一个下标i，若array[i]小于其孩子结点，不满足最大堆的性质，则通过使array[i]在最大堆中逐级下降来重新遵循最大堆的性质。*/
    private void maxHeapify(int[] array, int index) {
        int leftIndex = leftNode(index);
        int rightIndex = rightNode(index);
        int largest = index;
        if(leftIndex < heapSize && array[leftIndex] >= array[index]) {
            largest = leftIndex;
        }
        if(rightIndex < heapSize && array[rightIndex] >= array[largest]) {
            largest = rightIndex;
        }
        if(largest != index) {
            exchange(array, index, largest);
            maxHeapify(array, largest);
        }
    }
    //交换节点数据
    private void exchange(int[] array, int i, int j) {
        array[i] ^= array[j];
        array[j] ^= array[i];
        array[i] ^= array[j];
    }
    //得到左孩子下标
    private int leftNode(int index) {
        return index*2 + 1;
    }
    //得到右孩子下标
    private int rightNode(int index) {
        return index*2 + 2;
    }
}