我们知道堆的高度是log（n），其中n是元素的总数当我们执行heapify操作时，最后一级（h）的元素甚至不会移动一步。第二个最后一级（h-1）的元素数为2h-1，它们最多可以移动1级（在堆化期间）。类似地，对于第i层，我们有2i个元素可以移动h-i个位置。

因此，移动总数：

S=2h*0+2h-1*1+2h-2*2+。。。20*小时

S=2h｛1/2+2/22+3/23+…h/2h｝-------------------------------------------------1

这是AGP系列，用于解决两边除以2的问题S/2=2h｛1/22+2/23+…h/2h+1｝-------------------------------------------------2

从1中减去方程式2得到S/2=2h｛1/2+1/22+1/23+…+1/2h+h/2h+1｝S=2h+1{1/2+1/22+1/23+…+1/2h+h/2h+1}

现在1/2+1/22+1/23++1/2h是减小GP，其和小于1（当h趋于无穷大时，和趋于1）。在进一步的分析中，让我们对和取一个上限，即1。

这给出了：S=2h+1｛1+h/2h+1｝=2h+1+h~2h+h

h=对数（n），2h=n因此S=n+log（n）T（C）=O（n）

在构建堆时，假设您采用的是自下而上的方法。

您获取每个元素并将其与子元素进行比较，以检查该元素对是否符合堆规则。因此，叶被免费包含在堆中。那是因为他们没有孩子。向上移动，叶子正上方节点的最坏情况是1次比较（最多只能与一代孩子进行比较）再往上看，他们的直系父母最多可以与两代子女相比。继续朝着相同的方向，在最坏的情况下，您将对根进行log（n）比较。并且log（n）-1用于其直系子代，log（n）-2用于其直系子女，依此类推。所以总结起来，你会得到类似log（n）+{log（n（n）-1}*2+{log（n）-2}*4+…..+1*2^{（logn）-1}，它只是O（n）。

O（n）的证明

这个证明并不花哨，而且很简单，我只证明了完全二叉树的情况，结果可以推广到完全二叉。

已经有一些很好的答案，但我想补充一点直观的解释

现在，看看图片，有n/2^1个高度为0的绿色节点（此处23/2=12）n/2^2个高度为1的红色节点（此处23/4=6）n/2^3高度为2的蓝色节点（此处23/8=3）n/2^4个紫色节点，高度为3（此处23/16=2）因此高度h有n/2^（h+1）个节点要计算时间复杂度，可以计算每个节点完成的工作量或执行的最大迭代次数现在可以注意到，每个节点都可以执行（atmost）迭代==节点的高度

Green  = n/2^1 * 0 (no iterations since no children)  
red    = n/2^2 * 1 (heapify will perform atmost one swap for each red node)  
blue   = n/2^3 * 2 (heapify will perform atmost two swaps for each blue node)  
purple = n/2^4 * 3 (heapify will perform atmost three swaps for each purple node)   

因此，对于高度为h的任何节点，所做的最大功为n/2^（h+1）*h

现在完成的总工作量为

->(n/2^1 * 0) + (n/2^2 * 1)+ (n/2^3 * 2) + (n/2^4 * 3) +...+ (n/2^(h+1) * h)  
-> n * ( 0 + 1/4 + 2/8 + 3/16 +...+ h/2^(h+1) ) 

现在对于h的任何值，序列

-> ( 0 + 1/4 + 2/8 + 3/16 +...+ h/2^(h+1) ) 

永远不会超过1因此，构建堆的时间复杂度永远不会超过O（n）

你的分析是正确的。然而，它并不紧密。

要解释为什么构建堆是一个线性操作并不容易，您应该更好地阅读它。

这里可以看到对算法的详细分析。

主要思想是，在build_heap算法中，所有元素的实际堆化成本不是O（logn）。

当调用heapify时，运行时间取决于进程终止之前元素在树中向下移动的距离。换句话说，它取决于堆中元素的高度。在最坏的情况下，元素可能会一直下降到叶级别。

让我们一级一级地计算完成的工作。

在最底层，有2^（h）个节点，但我们没有对这些节点调用heapify，因此功为0。在下一级有2^（h−1）个节点，每个节点可能向下移动一级。在从底部开始的第3层，有2^（h−2）个节点，每个节点可能向下移动2层。

正如您所看到的，并不是所有的heapify操作都是O（logn），这就是为什么您会得到O（n）。

连续插入可通过以下方式描述：

T = O(log(1) + log(2) + .. + log(n)) = O(log(n!))

通过starling近似，n！=~O（n^（n+O（1））），因此T=~O（nlog（n））

希望这有帮助，O（n）的最佳方式是对给定集合使用构建堆算法（排序无关紧要）。