python算法--堆排序详细实现

堆排序的时间复杂度也 O(nlog n)，而且只需要一个记录大小的辅助空间。

对n个元素的序列 {k1, k2, ..., kn}，若将此序列看成是一个完全二叉树，若 对所有节点，其关键字均恒小于（或大于）左右孩子的关键字，则称该序列为堆。

使用堆排序，无非就是两步：1、建立堆 2、取出堆顶元素之后调整序列为新堆。

调整：

输出堆顶元素之后，将最后的元素放在堆顶（即k0）的位置，然后从 0 号节点开始，向下调整。如果节点和左右孩子节点相比不是最小的，则将较小的孩子节点与之
交换。交换之后，可能会破坏子树的堆属性，所以需要从交换的孩子节点处向下循环查找比较，直至子树满足堆属性或者到达叶子节点。

建堆：

将序列看成是一个完全二叉树，则二叉树的最后一个非终端节点即为第 n/2 个元素。所以，从第 n/2 个元素开始调整即可，依次是 n/2 - 1， n/2 - 2 ，......，0. 调整过程与上面是一样的。

完整代码如下：

#!/usr/bin/python
# FileName: HeapSort.py

# If the node has only one child
def changeTwo(array, i):
if array[i] > array[i*2+1]:
array[i], array[i*2+1] = array[i*2+1], array[i]

# If the node has two children
def changethree(array, i):
if array[i] > array[i*2+1] and array[i] > array[i*2+2]:
if array[i*2+1] > array[i*2+2]:
array[i], array[i*2+2] = array[i*2+2], array[i]
return i*2+2
else:
array[i], array[i*2+1] = array[i*2+1], array[i]
return i*2+1
elif array[i] > array[i*2+1] and array[i] <= array[i*2+2]:
array[i], array[i*2+1] = array[i*2+1], array[i]
return i*2+1
elif array[i] <= array[i*2+1] and array[i] > array[i*2+2]:
array[i], array[i*2+2] = array[i*2+2], array[i]
return i*2+2
return None

# From the node search downward, until reach the last parent node.
def adjustHeap(array, i):
s = len(array)
last = s / 2 - 1
while i != None and i < last:
i = changethree(array, i)

if i == last:
if s % 2 == 0:
changeTwo(array, last)# last has one child
else:
changethree(array, last)# last has two children

def heapSort(array):
'''Adjust the array from it's middle item to  it's first by
the method adjustHeap(), and in the end it will become a heap.'''
i = len(array) / 2 - 1
while i >= 0:
adjustHeap(array, i)
i -= 1
b = []
n = len(array)
for i in range(n):
array[0], array[len(array)-1] = array[len(array)-1], array[0]
b.append(array.pop(len(array)-1))
adjustHeap(array, 0)

return b

# ------------------------Test------------------------
import random

if __name__ == '__main__':

a = []

for i in range(20):
a.append(random.randint(0, 500))
print 'Before sort:'
print a

a = heapSort(a)
print 'After sort:'
print a

运行效果：