堆排序的JAVA实现及时间复杂度分析

堆排序是一个比较常用的排序方式，下面是其JAVA的实现：

1. 建堆

	// 对输入的数组进行建堆的操作
    private static void buildMaxHeap(int[] array, int length) {
        // 遍历所有的内部节点，每一个都进行siftdown操作
        for (int i = (int)Math.floor(length / 2 - 1); i >= 0; i--) {
            siftdown(array, length, i);
        }
    }
	
	private static void siftdown(int[] array, int length, int index) {
        // 1. 判断是否为叶子节点
        if (isLeaf(array, length, index)) {
            return;
        }

        // 2. 计算左右两个值的大小
        int max = Integer.MIN_VALUE;
        int maxIndex = index;
        // 判断该内部节点是否有两个子树
        if (2 * (index + 1) > length - 1) {
            max = array[2 * index + 1];
            maxIndex = 2 * index + 1;
        } else {
            // 对两个子树的值进行比较
            if (array[2 * index + 1] > array[2 * (index + 1)]) {
                max = array[2 * index + 1];
                maxIndex = 2 * index + 1;
            } else {
                max = array[2 * (index + 1)];
                maxIndex = 2 * (index + 1);
            }
        }

        // 3. 如需交换，交换后继续向下递归
        if (array[index] < array[maxIndex]) {
            array[maxIndex] = array[index];
            array[index] = max;
            siftdown(array, length, maxIndex);
        }
    }

    // 判断是否为叶子节点
    private static boolean isLeaf(int[] array, int length, int index) {
        return index > (int)Math.floor(length / 2 - 1);
    }

2. 堆排序

    private static void heapSort(int[] array) {
        buildMaxHeap(array, array.length);
        // 将堆顶的最大值每次都交换到最后，对剩余的数字进行新的建堆操作
        for (int i = 0; i < array.length; i++) {
            int temp = array[array.length - i - 1];
            array[array.length - i - 1] = array[0];
            array[0] = temp;
            buildMaxHeap(array, array.length - i - 1);
        }
    }

3. 时间复杂度

堆排序的时间复杂度主要有两个部分：

• 初始化建堆
• 每次取堆顶元素后，剩余部分的排序

因此，我们来分别看一下这两个部分的时间复杂度

• 对于初始化建堆：我们需要对除了叶子节点这一层的其他节点都进行遍历，每一个点假设都递归到了叶子节点，需要 k - i 次siftdown操作，而每一层有 2^(i - 1) 个节点，（i代表层数，设根节点为第一层）即，我们需要计算 2^(i - 1) * (k - i) ，当 i 取值为 1 到 n - 1时的值的和。
  即求： $$\sum _{i=1}^{n-1}(n-i)2^{i-1}$$
  计算过程如下：
  $$\sum _{i=1}^{n-1}(n-i)2^{i-1}=\sum _{i=1}^{n-1}n\ast 2^{i-1}-\sum _{i=1}^{n-1}i\ast 2^{i-1}$$
  对于前半部分：
  $$\sum _{i=1}^{n-1}n\ast 2^{i-1}=n\ast \sum _{i=1}^{n-1}{2}^{i-1}=n\ast \frac{1\ast (1-2^{n-1})}{1-2}=n\ast 2^{n-1}-n$$
  对于后半部分：
  $$S_n=\sum _{i=1}^{n-1}i\ast 2^{i-1}=2^0+2\ast 2^1+3\ast 2^2+...+(n-1)\ast 2^{n-2}$$
  $$2\ast S_n=2\ast \sum _{i=1}^{n-1}i\ast 2^{i-1}=2^1+2\ast 2^2+3\ast 2^3+...+(n-1)\ast 2^{n-1}$$
  $$S_n-2\ast S_n=-S_n=2^0+2^1+2^2+...+2^{n-2}-(n-1)\ast 2^{n-1}=2^n-1-n\ast 2^{n-1}$$
  即，两部分相加，有：
  $$n\ast 2^{n-1}-n+2^n-1-n\ast 2^{n-1}=2^n-1-n$$
  由于，n代表的是层数，它可以由 n = log N 求得，代入，有：N - 1 - log N，故时间复杂度 O(N) = N
• 第二部分，是关于排序的，我们交换堆顶元素不断放置到堆的末尾。即堆的元素是越来越少，我们比较的次数也减少，即求：
  $$log(n-1)+log(n-2)\dots +log3+log2\approx log(n!)$$
  可以证明log(n!)和nlog(n)是同阶函数：
  　　$$\because (n/2{)}^{n/2}\le n!\le n^n\therefore n/2\log (n/2)\le \log (n!)\le n\log (n)$$
  　
  即可以知道第二部分的时间复杂度为O(nlogn)

将两部分结合起来，我们可以获得时间复杂度为O(n) = O(n + nlogn) = O(nlogn)