算法学习笔记(5)-堆排序

public class HeapSort {

    public static void heapSort(int[] a) {
        int n = a.length - 1;
        //构造一个大顶堆,时间复杂度O（n）
        for (int k = n / 2; k >= 0; k--) {
            //从最后一个非叶子节点开始往上进行节点下沉，构造大顶堆
            sink(a, k, n);
        }

        //进行真正的堆排序，时间复杂度O(n) * O(logn) = O(nlogn)
        while (n > 0) {
            //取出根节点（最大值）和最后一个节点交换并且对这个节点进行调整，使堆平衡
            swap(a, 0, n--);
            //调整
            sink(a, 0, n);
        }
    }


    /**
     * @auther: Arong
     * @description: 将a构造成k到n的大顶堆
     * @param: [a, k, n]
     * @return: void
     * @date: 19-5-15 下午11:38
     */
    public static void sink(int[] a, int k, int n) {
        // 以0为开始索引
        while (2 * k + 1 <= n) {
            int j = 2 * k + 1;
            //当右节点大于左节点时，让j指向右节点
            if (j < n && a[j] < a[j + 1]) {
                j++;
            }
            //当a[k]大于等于a[j]时，说明位置正确，无需调整
            if (a[k] >= a[j]) {
                break;
            }
            //a[k]小于a[j]，交换位置以调整
            swap(a, k, j);
            //重新定位节点
            k = j;
        }
    }
    private static void swap(int[] a, int i, int j) {
        int temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }



    @Test
    public void fun() {
        int[] array = {6, 2, 1, 6, 9, 3, 5, 0, -1, -4};
        heapSort(array);
        System.out.println(Arrays.toString(array));
    }
}