堆排序

• 平均时间复杂度: O(n*logn)
• 最优时间复杂度: O(n*logn)
• 最差时间复杂度: O(n*logn)
• 空间复杂度 : O(1)
• 稳定性 : 不稳定

public class HeapSort {
    public static void heapSort(int[] data) {
        if (data == null || data.length == 0) {
            return ;
        }
        for (int i = 0; i < data.length; i++) {
            heapInsert(data, i);
        }
        int size = data.length;
        swap(data, 0, --size);
        while(size > 0) {
            heapify(data, 0, size);
            swap(data, 0, --size);
        }
    }
    private static void heapInsert(int[] data, int i) {
        while (data[i] > data[(i-1)/2]) {
            swap(data, i, (i-1)/2);
            i = (i - 1) / 2;
        }
    }
    private static void heapify(int[] data, int index, int size) {
        int left = index * 2 + 1;
        while(left < size) {
            int largest = left + 1 < size && data[(left + 1)] > data[left] ? left +1 : left;
            largest = data[index] < data[largest] ? largest : index;
            if (largest == index) {break;}
            swap(data, index, largest);
            index = largest;
            left = index * 2 + 1;
        }

    }
}