非递归方式实现堆排序

算法复杂度：n*log(n),即每次调整堆的时间复杂度为lon(n)，总的时间复杂度为log(n)+log(n-1)+..+log(1) =log(n!) =nlog(n)

每次都为对二叉树做搜索

思路：

①顺序存储方式初始化堆

②逐步调整堆

#交换
def swap(arr,i,j):
    temp = arr[i]
    arr[i] = arr[j]
    arr[j] = temp
#初始化最大堆，顺序存储
def heapInsert(arr,index):
    parent = 0
    
    while index != 0:
        parent = (index-1) // 2
        
        if arr[parent] < arr[index]:
            swap(arr,index,parent)
            index = parent
        else:
            break
#调整堆
def heapify(arr,index,size):
    left = index*2 + 1
    right = index*2 + 2
    largest = index
    
    while (left < size):
        
        if arr[largest] < arr[left]:
            largest = left
            
        if right < size and arr[largest] < arr[right]:
            largest = right
            
        if largest != index:
            swap(arr,index,largest)
        else:
            break
        index =  largest
        left = index*2+1
        right = index*2 + 2
#主函数，先初始化最大堆，再逐次调整堆
def heapSort(arr):
    for index in range(len(arr)):
        heapInsert(arr,index)  
        
    for index in range(len(arr)-1,-1,-1):
        swap(arr,0,index)
        heapify(arr,0,index)

if __name__ == '__main__':
    lis = [3,4,6,1,5,7,9,0,2]
    heapSort(lis)

 初始化堆的时间复杂度