用调整法和插入法建堆的Python实现，不同建堆方式对堆排序性能的影响

       建堆的方式大体有两种，一种是插入法，一种是调整法，其中以调整法比较常见。由于他们的建堆的思路不同，所以两种方法建堆结果可能不一样。

       插入法建堆是将数组1中的元素逐个插入到数组2中建立一个堆。以小根堆为例，每插入一个关键字就与其父节点的关键字比较大小，如果父节点的关键字较大则交换，然后依次自底地向上调整使之符合小根堆的特性。在某棵已插入根节点的子树中，当插入左节点时，左节点与根节点交换，插入右节点时，右节点与根节点交换，那么这种情况下这颗子树三个节点的位置都发生改变了。因此插入法建堆结果与插入的顺序和值大小有关。

       调整法建堆是自底向上依次调整，一棵子树中最小的节点值与根节点交换，最大的那个节点位置在本次调整中不作改变。即这种方法建堆有一个节点位置不变。

        下面是插入法和调整法建堆的Python代码：

import random
import datetime

#make random file
def creatIntRandom():
    count = 100
    output = open('data_100.txt','w+')
    while count:
        output.write(str(random.randint(0,1000001)) + '\n')
        count = count - 1
    output.close

def txtToList():
    int_list = []
    in_file = open('data.txt')
    in_text = in_file.readlines()   
    for line in in_text:
        num = int(line[0 : len(line) - 1])
        int_list.append(num) 
    in_file.close()
    return int_list

#----------------------------------
def minHeapify(list, heapsize, index):
    left = 2*index + 1
    right = 2*index + 2
    mini = index
    if left < heapsize:
        if list[mini] > list[left]:
            mini = left
        if right < heapsize and list[mini] > list[right]:
            mini = right
    if mini != index:
        list[mini], list[index] = list[index], list[mini]
        minHeapify(list, heapsize, mini)

def buildMinHeap_1(list):
    heapSize = len(list)
    if heapSize < 2:
        return
    for i in range(heapSize/2 - 1, -1, -1):
        minHeapify(list, heapSize, i)

def heapSort_1(list):
    buildMinHeap_1(list)
    for i in range(len(list) - 1, -1, -1):
        list[0], list[i] = list[i], list[0]
        minHeapify(list, i, 0)
    return list    

#-------------------------------------------
def buildMinHeap_2(list_1):
    heapsize = 0
    list_2 = [0]*(len(list_1) + 1)
    for i in range(len(list_1)):
        heapsize = i + 1
        list_2[heapsize] = list_1[i]
        while heapsize > 2 and list_2[heapsize/2] > list_2[heapsize]:
            list_2[heapsize], list_2[heapsize/2] = list_2[heapsize/2], list_2[heapsize]
            heapsize/=2
    return list_2[1:len(list_2)]

def heapSort_2(list):
    list_2 = buildMinHeap_2(list)
    for i in range(len(list)-1, -1, -1):
        list_2[0], list_2[i] = list_2[i], list_2[0]
        minHeapify(list_2, i, 0)
    return list_2

#------------------------------------------
def verify(list):
    for i in range(len(list) - 1):
        if list[i] >= list[i+1]:
            pass
        else:
            return False
    return True

def test():
    list_in = txtToList()

    time_start_1 = datetime.datetime.now()
    list_out_1 = heapSort_1(list_in)
    time_end_1 = datetime.datetime.now()
    #print list_out_1
    print verify(list_out_1)
    print (time_end_1 - time_start_1)

    time_start_2 = datetime.datetime.now()
    list_out_2 = heapSort_2(list_in)
    time_end_2 = datetime.datetime.now()
    #print list_out_2
    print verify(list_out_1)
    print (time_end_2 - time_start_2)

#creatIntRandom()
test()

        下图是对100W个随机产生的整数进行堆排序的运行结果：

    

 

        调整法的时间复杂度：建堆耗时0.5NlogN，排序耗时NlogN，累计1.5NlogN。
        插入法的时间复杂度：建堆耗时NlogN，排序耗时NlogN，累计2NlogN。
        从以上的比较中可以看出，虽然两种方法的时间复杂度在数量级是一样的，但是由于建堆所耗费的时间不同，总体时间有所不同，从上图执行的结果可以看出来：上面是调整法建堆并排序所耗时间，下面是插入法建堆并排序所耗时间。基本符合上述分析。