建堆的算法复杂度分析 O(n)

代码：

template<class T> inline void MaxHeap<T>::make_heap(vector<T> & v) {      if (heap_.size() != 0)          heap_.clear();      heap_ = v;        // start with last parent, and reheapify_down back to root      for (int i = parent(v.size() - 1); i >= 0; i--)          reheapify_down(i);        v = heap_;  }  

template<class T> inline void MaxHeap<T>::reheapify_down(int i) {      if (heap_.empty())          return;        int current = i, max = i;      int left = 1, right = 2;      int size = heap_.size();        do {          current = max;          left = left_child(current);          right = right_child(current);          if (left < size && heap_[left] > heap_[current])              max = left;          if (right < size && heap_[right] > heap_[max])              max = right;          if (max != current)              swap(heap_[current], heap_[max]);      } while (max != current);  }  

看似建堆(make_heap)的复杂度为O(nlogn)，实则为O(n)，reheapify_down不会touch到每个节点，所以不算简单的递归，只能算叠加。证明如下：

因为堆构建的是一颗平衡二叉树。于是有：

1. 一棵拥有n个节点的平衡二叉树，树高 h 约为 lg n 。

2. 树的第 i 层 最多有节点 2^i 个。注意，第 i 层的高度为 i + 1。如第0层的高度为1，拥有1个根节点。

那么做reheapify_down时，最底层(h-1)的节点不会动，倒数第二层（h-2）的节点最多往下移动一次，倒数第三层（h-3）的节点最多往下移动2次....第0层的节点往下最多移动（h-1）次。

所以，最坏情况下，每层所有节点都会往下移到最底层。

则，所有操作总和为     S = 2^(h-1)*0 + 2^(h-2)*1 + 2^(h-3) * 2 + ... + 2^1*(h-2) + 2^0*(h-1)        ----- （1）

把（1）式乘以2，再减去（1）式， 可得

S = 2^(h-1) + 2^(h-2) + ... + 2^1 - 2^0*(h-1)  = 2(1-2^(h-1))/(1-2) - (h-1) = 2^h - h- 1      ---- (2)

把h = lg n 代入 （2）式， 得 S = n - lgn - 1 <= n   (n >=1)

故而， 建堆复杂度为O(n) 。