堆排序

堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。堆排序可以说是一种利用堆的概念来排序的选择排序。

def heapify(arr, n, i): 
    largest = i  
    l = 2 * i + 1     # left = 2*i + 1 
    r = 2 * i + 2     # right = 2*i + 2 
  
    if l < n and arr[i] < arr[l]: 
        largest = l 
  
    if r < n and arr[largest] < arr[r]: 
        largest = r 
  
    if largest != i: 
        arr[i],arr[largest] = arr[largest],arr[i]  # 交换
  
        heapify(arr, n, largest) 
  
def heapSort(arr): 
    n = len(arr) 
  
    # Build a maxheap. 
    for i in range(n, -1, -1): 
        heapify(arr, n, i) 
  
    # 一个个交换元素
    for i in range(n-1, 0, -1): 
        arr[i], arr[0] = arr[0], arr[i]   # 交换
        heapify(arr, i, 0) 
  
arr = [ 12, 11, 13, 5, 6, 7] 
heapSort(arr) 

　　

时间复杂度
堆排序的时间复杂度分为两个部分一个是建堆的时候所耗费的时间，一个是进行堆调整的时候所耗费的时间。而堆排序则是调用了建堆和堆调整。

刚刚在上面也提及到了，建堆是一个线性过程，从 l e n ( h e a p S i z e ) / 2 len(heapSize)/2len(heapSize)/2 一直调用堆调整的过程，相当于 O ( h 1 ) + O ( h 2 ) + … + O ( h l e n ( h e a p S i z e ) / 2 ) O(h_1) + O(h_2) + … + O(h_{len(heapSize)/2})O(h
1
​
)+O(h
2
​
)+…+O(h
len(heapSize)/2
​
) 这里的 h hh 表示节点深度， l e n ( h e a p S i z e ) / 2 len(heapSize)/2len(heapSize)/2 表示节点最大深度，对于求和过程，与数组长度 h e a p S i z e heapSizeheapSize 线性相关，时间复杂度为 O ( n ) O(n)O(n) 。

堆调整为一个递归的过程，调整堆的过程时间复杂度与堆的深度有关系，相当于 l o g n lognlogn 的操作。

因为建堆的时间复杂度是 O ( n ) O(n)O(n) ，调整堆的时间复杂度是 O ( l o g n ) O(logn)O(logn) ，所以堆排序的时间复杂度是 O ( n l o g n ) O(nlogn)O(nlogn) 。