標準的堆插入元素的算法很好理解，而且也很容易知道向堆中插入一個元素的代價是lgn。
按照最常規的想法，把一個數組中所有元素添加到一個堆中，依次壓入即可。壓入n個元素的代價就是
Sum[Log2[i],{1,i,n}]。
結果等於Log2[n!].根據斯特林公式，n!在n趨向於無窮大時可以近似看成(2Pi*n)^1/2*(n/E)^n。
因此，總代價可以看成n*Log2[n/E]+o(n),比O(n)的階要大一些。
直覺上，這個操作的複雜度應該是要比這個低的。因爲將n個元素完整排序的代價不過是nlgn。而堆應該是一個半排序。不應該接近nlgn。
這個直覺是正確的，heapify操作正是一個線性時間的算法.
舉個python的標準庫heapq裏面的實現
def cmp_lt(x, y):
# Use __lt__ if available; otherwise, try __le__.
# In Py3.x, only __lt__ will be called.
return (x < y) if hasattr(x, '__lt__') else (not y <= x)
def heapify(x):
"""Transform list into a heap, in-place, in O(len(x)) time."""
n = len(x)
# Transform bottom-up. The largest index there's any point to looking at
# is the largest with a child index in-range, so must have 2*i + 1 < n,
# or i < (n-1)/2. If n is even = 2*j, this is (2*j-1)/2 = j-1/2 so
# j-1 is the largest, which is n//2 - 1. If n is odd = 2*j+1, this is
# (2*j+1-1)/2 = j so j-1 is the largest, and that's again n//2-1.
for i in reversed(xrange(n//2)):
_siftup(x, i)
def _siftdown(heap, startpos, pos):
newitem = heap[pos]
# Follow the path to the root, moving parents down until finding a place
# newitem fits.
while pos > startpos:
parentpos = (pos - 1) >> 1
parent = heap[parentpos]
if cmp_lt(newitem, parent):
heap[pos] = parent
pos = parentpos
continue
break
heap[pos] = newitem
def _siftup(heap, pos):
endpos = len(heap)
startpos = pos
newitem = heap[pos]
# Bubble up the smaller child until hitting a leaf.
childpos = 2*pos + 1 # leftmost child position
while childpos < endpos:
# Set childpos to index of smaller child.
rightpos = childpos + 1
if rightpos < endpos and not cmp_lt(heap[childpos], heap[rightpos]):
childpos = rightpos
# Move the smaller child up.
heap[pos] = heap[childpos]
pos = childpos
childpos = 2*pos + 1
# The leaf at pos is empty now. Put newitem there, and bubble it up
# to its final resting place (by sifting its parents down).
heap[pos] = newitem
_siftdown(heap, startpos, pos)heapify操作主要有3個過程，heapify對一半的元素調用_siftup，而_siftup又調用了_siftdown。
這個過程作用的原理是什麼？
_siftup(heap，pos)最開始部分的代碼很明顯，就是把pos處的元素沿着最小路徑一路向下降到底。途中所比較的子節點依次上浮一層。而_siftdown(heap,startpos,ps)過程則是標準的堆插入動作，將pos處的元素上浮直到小於startpos時停止，也就是startpos的左兄弟節點或上一層節點。
這可以理解爲一個從倒數第二層開始構建堆的過程。第一輪循環把最下面兩層的3個節點的元素變成堆，再依次向上，通過插入一個上一層元素，將兩個堆合併。因爲每上一層，這層下面的兩個元素分別都是這兩棵子樹的最小元素。
這個過程可以看成類似數學歸納法的原理。第一個元素成立，而n成立確保n+1成立，因此對所有元素就成立。逐個插入的問題規模是線性增長的，比如比n小的元素是n-1，而歸併操作的問題規模是折半的。這就相當於在逐次插入元素的時候，當插到第四個元素的時候，停止向原堆插入，而向新堆插入。當兩個堆平衡以後，再將兩個堆合併。
因此，他的時間T(n)=2T(n/2)+2lg(n/2)
這剛好落入了主方法的第一種情況，因此他的複雜度是O(n)
舉個7個元素的例子。x=[a,b,c,d,e,f,g]。單純計算比較次數
在最壞情況下，逐個插入算法
1.插入a
2.插入b,a與b比較一次
3.插入c,a魚c比較一次
4.插入d,d與b比較一次，再與a比較一次
5.插入e，e與b比較一次，再與a比較一次
6.插入f,f與c比較一次,在與a比較一次
7.插入g,g與c比較一次，再與a比較一次
共計比較10次。
而heapify算法：
1.a與b、c各比較一次
2.d與e、f各比較一次
3.a與d比較一次
4.g與a比較一次
5.b與c比較一次
6.g與b比較一次
共計比較8次。