算法导论程序11--堆排序算法（Python）

堆排序算法： def heapsort(self,A):

开始的时候，利用build_max_heap将输入数组A建成最大堆。因为数组中的最大元素总在根结点A[0]中。通过把它与A[len(A)-1]交换。可以让元素A[0]放到正确的位置。

这个时候，我们从堆中去掉A中的最后一个结点。即heap_size-1。其实heap_size起作用的地点主要在函数max_heapify(self,heap_size,A,i)中，就是维护堆的性质中，可以控制堆的大小。然后调用max_heapify(heap_size,A,0)这时候已经变成少一个元素的堆了。即是在元素A[0....len(A)-2]上构建的新的最大堆。

堆排序算法会不断重复这个过程。直到堆的大小从len(A)降到1。

import math
class heapsort:
def __init__(self,a_A,a_heap_size):
self.list=a_A
self.heap_size = a_heap_size
def parent(self,i):
return math.floor((i-1)/2)
def left(self,i):
return 2*i+1
def right(self,i):
return 2*i+2
def max_heapify(self,heap_size,A,i):
largest = i
key = A[i]
l = self.left(i)
r = self.right(i)
if l<heap_size and A[l] > A[largest]:
largest = 2*i+1
if r<heap_size and A[r] > A[largest]:
largest = 2*i+2
A[i]=A[largest]
A[largest]=key
if largest != i:
self.max_heapify(heap_size,A,largest)
return A
def build_max_heap(self,A):
N = math.floor(len(A)/2)-1
heap_size=len(A)
for i in range(N,-1,-1):
A = self.max_heapify(heap_size,A,i)
return A
def heapsort(self,A):
self.build_max_heap(A)
heap_size=len(A)
for i in range(len(A)-1,0,-1):
temp = A[0]
A[0] = A[i]
A[i] = temp
heap_size-=1
self.max_heapify(heap_size,A,0)

运行：

>>> A=[16,4,10,14,7,9,3,2,8,1]
>>> p = heapsort(A,10)
>>> p.heapsort(A)

>>> A
[1, 2, 3, 4, 7, 8, 9, 10, 14, 16]

def heapsort的时间复杂度是O(nlgn)
调用build_max_heap的时间复杂度是O(n)

一共n-1次调用max_heapify,每次的时间时O(lgn)

所以heapsort的时间复杂度是O(nlgn)