两种方法推导建堆的时间复杂度O(n)

可以通过siftdown或者siftup建立二叉堆。

siftdown：如果节点小于其最大的子节点，将二者进行交换，直到节点大于或等于所有子节点。整个过程节点向下调整。
siftup：如果节点大于其父节点，将二者交换，直到节点小于或者等于其父节点。整个过程节点向上调整。

siftdown或者siftup在最坏情况下都是O(logn)。siftdown操作次数取决于节点离堆底的距离，siftup的操作次数取决于节点离堆顶的距离。siftdown的效率更高一些，因为建堆时计算每个节点到底部或者顶部的距离，由于大部分节点靠近底部，siftdown的总体操作次数少一些。

通过siftdown建堆

代码

   //swap current value with the largest child.private static void siftdown(int[] arr, int k, int len){while(2 * k + 1 < len){int child = 2 * k + 1;if(2 * k + 2 < len && arr[2 * k + 1] < arr[2 * k + 2]){child = 2 * k + 2;}if(arr[k] >= arr[child]){break;}int temp = arr[k];arr[k] = arr[child];arr[child] = temp;k = child;}}//O(logn)public static void buildheap(int[] arr){for(int i = arr.length - 2; i >= 0; i--){siftdown(arr, i, arr.length);}}

二叉堆中
倒数第一层（堆底）的节点不需要通过siftdown交换，0次操作 * ( n/2 个节点 )
倒数第二层的节点最多进行1次交换到堆底，1次操作 * n/4个节点
倒数第三层的节点最多进行2次交换到堆底，2次操作 * n/8个节点
…
第一层的最多进行h （h 是二叉堆的深度）次交换到堆底，h次操作 * 1 个节点

如何确定每一层的节点数？
假设二叉堆的最后一层是满的。二叉树所有节点数和为
1+2+4+...+2h=n2h+1−1=n2h=n+12h=log2(n+1)−11 + 2 + 4 + ... + 2^h = n \\ 2^{h + 1} - 1 = n \\ 2^h = \frac{n + 1}{2} \\ h = log_2(n + 1) - 1 1+2+4+...+2h=n2h+1−1=n2h=2n+1h=log2(n+1)−1
x 是二叉堆深度，n是整个节点个数。最后一层的节点数是2h2^h2h 约为n2\frac{n}{2}2n。根据二叉堆的特性，前面一层的节点数是后一层的12\frac{1}{2}21。依次得出倒数第二层的节点数是n4\frac{n}{4}4n，倒数第三层的节点数是n8\frac{n}{8}8n，等等。

交换次数总共为
sum=0×n2+1×n4+2×n8+...+h×1,h=lognsum = 0 \times \frac{n}{2} + 1 \times \frac{n}{4} + 2 \times \frac{n}{8} + ... + h \times 1, h = logn sum=0×2n+1×4n+2×8n+...+h×1,h=logn

推导方法1:

公式2：每一项都是正数，因此有限的区间求和小于无限区间求和
公式3: 指数求导的公式
公式4: 等比数列求和公式
公式5: 指数求导公式

推导方法2:

综上，采用siftdown建堆的时间复杂度O(n)。

通过siftup建堆

详细代码见

    //swap current value with its parent if parent is less than current valueprivate static void siftup(int[] arr, int k){while(k > 0){int parent = (k - 1) / 2;//terminate when arr satisfies the heap characteristicif(arr[k] <= arr[parent]){break;}//otherwise, swap curr value with its parent, keep siftupint temp = arr[k];arr[k] = arr[parent];arr[parent] = temp;k = parent;}}public static buildheap(int[] arr){for(int i = 1; i < arr.length; i++){siftup(arr, i);}
}

通过siftup建立二叉堆的时间复杂度是O(nlogn)。
二叉堆中，
第一层的节点不需要交换，0次操作 * 1 个节点
第二层的节点最多进行1次交换到堆顶，1次操作 * 2个节点
第三层的节点最多进行2次交换到堆顶，2次操作 * 4个节点
…
底层的最多进行h （h 是二叉堆的深度）次交换到堆顶，h次操作 * n/2 个节点

交换次数总共为
sum=h×n2+(h−1)×n4+(h−2)×n8+...+0×1,h=lognsum = h \times \frac{n}{2} + (h - 1) \times \frac{n}{4} + (h - 2) \times \frac{n}{8} + ... + 0 \times 1, h = logn sum=h×2n+(h−1)×4n+(h−2)×8n+...+0×1,h=logn

其中，第一项h×n2=logn×n2h \times \frac{n}{2} = logn \times \frac{n}{2}h×2n=logn×2n，最好的情况时间复杂度已经是O(nlogn)