算法导论学习笔记(一)排序算法之堆排序

堆数据结构就像它的名字一样，如同一座金字塔；堆可以被看作一棵近似的完全二叉树，且它需维持一个性质——在任何一个节点处，其权值均小于或均大于其子树节点。
而根据完全二叉树的特点，即任何一个节点的左子树节点号为该节点号乘以二，而右子树节点号为该节点乘以二并加一，可以快速得访问任何一个节点，使得堆的性质得以维护。
堆排序就是利用堆的性质，找到各元素所在位置。

算导的伪代码

//计算一个节点的父节点、左孩子、右孩子的下标

PARENT( i )
1   return i/2

LEFT( i )
1   return 2*i

RIGHT( i )
1   return 2*i+1

---

//维护堆的性质

MAX-HEAPIFY(A,i)
1   l = LEFT( i )
2   r = RIGHT( i )
3   if l <= A.heap-size and A[l] > A[i]
4       largest = l
5   else largest = i
6   if r <= A.heap-size and A[r] > A[largest]
7       largest = r
8   if largest != i
9       exchange A[i] with A[largest]
10      MAR-HEAPIFY(A,largest)

---

//建堆（最大堆）

BUILD-MAX-HEAP( A )
1   A.heap-size = A.length
2   for i = A.length/2 downto 1
3       MAX-HEAPIFY(A,i)

---

//堆排序

HEAPSORT( A )
1   BUILD-MAX-HEAP( A )
2   for i = A.length downto 2
3       exchange A[1] with A[i]
4       A.heap-size = A.heap-size - 1
5       MAX-HEAPIFY(A,1)

算法分析

堆排序的时间复杂度为O(n lg n)，它与分治排序的时间复杂度是一样的，但不同的是堆排序是一种原址排序。但在实际运用中，快排一般优于堆排序。

代码片段

inline int PARENT(int i)
{
    return i/2;
}
inline int LEFT(int i)
{
    return i<<1;
}
inline int RIGHT(int i)
{
    return i<<1|1;
}
void exchange(int *a,int *b)
{
    if((*a) != (*b)){
       (*a)^=(*b);
       (*b)^=(*a);
       (*a)^=(*b);
    }
}
void maxHeapify(int *sortArray,int node,int heapSize)
{
    int left = LEFT(node);
    int right = RIGHT(node);
    int largest = node;
    if(left <= heapSize && sortArray[left] > sortArray[node]){
       largest = left;
    }
    if( right <= heapSize && sortArray[right] > sortArray[largest]){
       largest = right;
    }
    if( largest != node){
       exchange(&sortArray[node],&sortArray[largest]);
       maxHeapify(sortArray,largest,heapSize);
    }
}
void buildMaxHeap(int *sortArray,int length)
{
    for(int i=length/2;i>0;--i){
       maxHeapify(sortArray,i,length);
    }
}
void heapSort(int *sortArray,int length)
{
    buildMaxHeap(sortArray,length);
    for(int i=length;i>1;--i){
       exchange(&sortArray[1],& sortArray[i]);
       maxHeapify(sortArray,1,i-1);
    }
}