排序算法——堆排序(递归版本)

堆积排序(Heapsort)是指利用堆积树(堆)这种数据结构所设计的一种排序算法。堆积树是一个近似完整二叉树的结构,并同时满足堆积属性:即子结点的键值或索引总是小于(或者大于)它的父结点。

在堆积树的数据结构中,堆积树中的最大值总是位于根节点。堆积树中定义以下几种操作:
1.最大堆积调整(max_heapify):将堆积树的末端子结点作调整,使得子结点永远小于父结点
2.建立最大堆积(build_max_heap):将堆积树所有数据重新排序
3.堆积排序(heap_sort):移除位在第一个数据的根结点,并做最大堆积调整的递归运算

最坏时间复杂度 O(nlogn)
堆排序是不稳定的排序算法

Code:
  1. #include    
  2.   
  3. void max_heapify(int a[], int parent, int heap_size)   
  4. {   
  5.     int l, r, largest, temp;   
  6.        
  7.     l = (parent << 1) + 1;   
  8.     r = l + 1;   
  9.     largest = parent;   
  10.   
  11.     if (l <= heap_size && a[l] > a[largest]) {   
  12.         largest = l;   
  13.     }   
  14.     if (r <= heap_size && a[r] > a[largest]) {   
  15.         largest = r;   
  16.     }   
  17.     if (largest != parent) {   
  18.         temp = a[parent];   
  19.         a[parent] = a[largest];   
  20.         a[largest] = temp;   
  21.         max_heapify(a, largest, heap_size);   
  22.     }   
  23. }   
  24.  
  25. void build_max_heap(int a[], int heap_size)   
  26. {   
  27.     int i;   
  28.     for (i = heap_size / 2; i >= 0; i--) {   
  29.         max_heapify(a, i, heap_size);   
  30.     }   
  31. }   
  32.   
  33. void heap_sort(int a[], int heap_size)   
  34. {   
  35.     int i, temp;   
  36.     build_max_heap(a, heap_size);   
  37.     for (i = heap_size; i >= 0; i--)   
  38.     {   
  39.         temp = a[i];   
  40.         a[i] = a[0];   
  41.         a[0] = temp;   
  42.         heap_size--;   
  43.         max_heapify(a, 0, heap_size);   
  44.     }   
  45. }   
  46.   
  47. int main()   
  48. {   
  49.     int a[] = {46,79,56,38,40,84}, i;   
  50.     int size = sizeof(a) / sizeof(int);   
  51.     heap_sort(a, size - 1);   
  52.   
  53.     for (i = 0; i < size; i++) {   
  54.         printf("%d ", a[i]);   
  55.     }   
  56.     return 0;   
  57. }  

你可能感兴趣的:(排序算法——堆排序(递归版本))