一，建堆的时间复杂度分析
堆是一颗完全二叉树，满二叉树又是一颗特殊的完全二叉树。
对于满二叉树来说，第一层的节点个数为2^0,第二层的节点个数为2^1,......所以可以得到第h层的节点个数为2^(h-1)。总结点个数N=2^0+2^1+...+2^(h-1)=2^h-1。那么就可以得出高度和节点个数的关系h=log（N+1）。
对于完全二叉树来说，最少情况下是上图中，最后一层只有一个节点，最多情况就是一个满二叉树。最少情况下，N=2^0+2^1+...+2^(h-2)+1=2^(h-1),同样高度和节点个数的关系：h=logN+1;
向上调整建堆和向下调整建堆的算法（内容在上一节中），最坏情况下都是要调整高度次，所以时间复杂度都是O(logN).
二，堆排序的时间复杂度分析
堆排序的大致思路：先将数据建堆（有4，），再将堆顶数据和最后一个数据交换，将除最后一个数据外的剩下数据重新建堆，反复执行，最大或最下的数据就会被放在后面，最后就得到一组有序数据。
//堆排序
void HeapSort(int* a, int n)
{
//升序，建大堆
//降序，建小堆
//向下调整建堆
//从第一个非叶子节点开始
for (int i = (n - 1 - 1) / 2; i >= 0; i--)
{
AdjustDown(a, n, i);
}
int end = n - 1;
while (end > 0)
{
swap(&a[0], &a[end]);//交换
AdjustDown(a, end, 0);//重新建堆
end--;
}
}1，使用向下调整建堆
可能在只看代码时，会认为一个for循环，加上向下调整算法，时间复杂度是O(N*logN),其实不然，时间复杂度是O(N)。
向下调整建堆的思路：从第一个非叶子节点开始，使用向下调整算法，使它的左右子树都调成大堆或者小堆，依次循环。
时间复杂度分析：
第一层有2^0个节点，每个节点最多向下调整h-1次。
第二层有2^1个节点，每个节点最多向下调整h-2次。
第三层有2^2个节点，每个节点最多向下调整h-3次。
......
第h-1层有2^(h-2)个节点，每个节点最多向下调整1次。
最多需要调整的次数：
F(h)=2^0*(h-1)+2^1*(h-2)+2^2*(h-3)+...+2^(h-2)*1
2F(h)=2^1*(h-1)+2^2*(h-2)+2^3*(h-3)+...+2^(h-1)*1
相减得：F(h)=2^(h-1)+2^1+2^2+...+2^(h-2)-2^0*(h-1)
最后得：F(h)=2^h-1-h，再将h=logN代入：
F(h)=N-1-logN.（N的量级大于logN的量级）
所以向下建堆的时间复杂度为O(N)
2,使用向上调整建堆
向上调整建堆与向下相比，时间复杂度会更高。
//堆排序
void HeapSort(int* a, int n)
{
//升序，建大堆
//降序，建小堆
//向上调整建堆
for (int i = 1; i < n; i++)
{
AdjustUp(a, i);
}
int end = n - 1;
while (end > 0)
{
swap(&a[0], &a[end]);
AdjustDown(a, end, 0);
end--;
}
}
向上调整建堆的思路：将第一个数据看成是堆，从第二个数据开始，调用向上建堆算法，入一个数据，调用一次建堆。
时间复杂度分析：（从第二行开始）
第二行2^1个数据，每个数据向上调整1次
第三行2^2个数据，每个数据向上调整2次
......
第h行2^(h-1)个数据，每个数据向上调整h-1次
最多需要调整的次数：T(h)=2^1*1+2^2*2+...+2^(h-1)*(h-1)
2T(h)=2^2*1+2^3*2+...+2^h*(h-1)
相减得：T(h)=2^h*(h-1)-2^1-（2^2+2^3+...+2^(h-1))
T(h)=2^h*(h-1)-2^h+2
得：T(h)=(N+1)*(log(N+1)-1)-N+1
这个公式看最后一项就可以看出时间复杂度是O(N*logN),因为最后一行有2^(h-1)个节点，占整颗树节点的一半,还要调整h-1次。
3，比较
其实不难看出，向下建堆过程中，规律是：节点数量多的层*调整次数少，节点数量少得层*调整次数多。
向上建堆过程就相反，节点数量多的层*调整次数多，节点数量少得层*调整次数少。
所以向下调整建堆得时间复杂度更低。堆排序中用的也就是向下调整建堆。
4，重新建堆过程时间复杂度
while (end > 0)
{
swap(&a[0], &a[end]);
AdjustDown(a, end, 0);
end--;
}该过程是将建好的堆进行调整，交换堆顶数据和最后一个数据，然后将最后一个数据除外，重新形成一个堆，反复执行，使数据变得有序。
时间复杂度分析：
该过程每次都要调整，都是从第一个节点位置开始，N个节点，最多调整logN次，在加上一次循环，最多调整N*logN次。
该过程的时间复杂度是O(N*logN)
堆排序的时间复杂度为：O(N*logN)+O(N), 其中N*logN的量级更大
总结：堆排序的时间复杂度为O(N*logN)
