算法导论程序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)