堆排序

堆排序是原址排序，时间复杂度是0(nlgn).
思路：先把待排序的数组A构建成一个堆，那么堆顶是数组中元素的最大值，A[0]和A[n]交换，剩余的n-1个元素继续构建成堆，然后A[0] 和A[n-1]交换，剩余的n-2个元素继续构建成堆，重复上述步骤，直到剩下1个元素结束。

import random
def max_heapify(alist, i, heap_size):
    lc = 2 * i + 1
    rc = 2 * i + 2

    largest = i
    if lc <= heap_size:
        if alist[lc] > alist[i]:
            largest = lc

    if rc <= heap_size:
        if alist[rc] > alist[largest]:
            largest = rc

    if largest != i:
        alist[i], alist[largest] = alist[largest], alist[i]
        max_heapify(alist, largest, heap_size)


def build_heap(alist):
    n = len(alist)-1
    for i in range(int(n/2)+1, -1, -1):
        max_heapify(alist, i, n)


def heap_sort(alist):
    build_heap(alist)
    size = len(alist)-1
    for i in range(size, 0, -1):
        alist[0], alist[i] = alist[i], alist[0]
        size -= 1
        max_heapify(alist, 0, size)


if __name__ == "__main__":
    alist = random.sample(range(100), 30)
    print("alist: ", alist)
    heap_sort(alist)
    print("after sort: %s" % alist)