【转】算法之堆排序

http://blog.csdn.net/SJF0115/article/details/8610201

 

前序:

(二叉)堆数据结构是一种数组对象,它可以被视为一棵完全二叉树。树中每个节点与数组中存放该节点值的那个元素对应。

树的每一层都是填满的,最后一层除外。

树的根为a[1] (在这里是从1开始的,也可以从0开始),给定了某个节点的下标i,其父节点为i/2,左二子为2*i,右儿子为2*i+1。

二叉堆满足二个特性:

1.父结点的键值总是大于或等于(小于或等于)任何一个子节点的键值。

2.每个结点的左子树和右子树都是一个二叉堆(最大堆或最小堆)。

当父结点的键值总是大于或等于任何一个子节点的键值时为最大堆。

当父结点的键值总是小于或等于任何一个子节点的键值时为最小堆。

保持堆的性质:

MaxHeap是对最大堆进行操作的最重要的子程序。

以i为根的子树:

在算法每一步中,从a[i], a[Left(i)], a[Right(i)]找出最大值,并将其下标存在LargestIndex中。如果a[i]是最大的,则以i为根的子树已是最大堆,程序结束。

否则i的某个子结点中有最大元素则交换a[i],a[LargetIndex],从而使i及子女满足堆性质。下标为LargestIndex的结点在交换后的值为a[i],以该结点为根的子树又有可能违反最大堆的性质,因而又要对该子树递归调用MaxHeap,重新使子树平衡。

 

[cpp] view plaincopy
 
  1. //调整以index为根的子树  
  2. //n:堆中元素个数  
  3. int MaxHeap(int a[],int index,int n){  
  4.     int LargestIndex = index;  
  5.     //左子节点  
  6.     int LeftIndex = 2*index;  
  7.     //右子节点  
  8.     int RightIndex = 2*index+1;  
  9.     if(LeftIndex <= n && a[LeftIndex] > a[LargestIndex]){  
  10.         LargestIndex = LeftIndex;  
  11.     }  
  12.     if(RightIndex <= n && a[RightIndex] > a[LargestIndex]){  
  13.         LargestIndex = RightIndex;  
  14.     }  
  15.     //如果a[index]是最大的,则以index为根的子树已是最大堆否则index的子节点有最大元素  
  16.     //则交换a[index],a[LargetIndex],从而使index及子女满足堆性质  
  17.     int temp;  
  18.     if(LargestIndex != index){  
  19.         //交换a[index],a[LargetIndex]  
  20.         temp = a[index];  
  21.         a[index] = a[LargestIndex];  
  22.         a[LargestIndex] = temp;  
  23.         //重新调整以LargestIndex为根的子树  
  24.         MaxHeap(a,LargestIndex,n);  
  25.     }  
  26.     return 0;  
  27. }  

 

 

建堆:

我们可以自底向上的用MaxHeap来将一个数组a[1-n]变成一个最大堆,子数组a[n/2+1,........n]中的元素是树中的叶子,因此每个都可以看做只含一个元素的堆,满足最大堆的要求,不用调整。所以只需调整以a[n/2........1]中元素为根的子树使之成为最大堆。

[cpp] view plaincopy
 
  1. //建堆:将一个数组a[1-n]变成一个最大堆  
  2. int BuildMaxHeap(int a[],int n){  
  3.     int i;  
  4.     //子数组a[(n/2+1,n/2+2......n)]中的元素都是树中的叶子  
  5.     for(i = n/2;i >= 1;i--){  
  6.         //调整以i为根节点的树使之成为最大堆  
  7.         MaxHeap(a,i,n);  
  8.     }  
  9.     return 0;  
  10. }  

 

a数组

16 7 3 20 17 8

初始堆:

自底向上从最后一个非叶节点开始调整:

 

                       (a)                                                    (b)                                                 (c)                                                   (d)

每次调整都是从父节点、左孩子节点、右孩子节点三者中选择最大者跟父节点进行交换(交换之后可能造成被交换的孩子节点不满足堆的性质,因此每次交换之后要重新对被交换的孩子节点进行调整)。

堆排序:

开始时,堆排序先用BuildMaxHeap将输入数组a[1-n]构造成一个最大堆。又因为数组中最大元素在根a[1],则可以通过它与a[n]交换来达到最终的正确位置。

现在,如果从堆中”去掉“结点n(不是真的删除,而是通过修改堆的元素个数n),可以很容易的将a[1-(n-1)]建成最大堆。原来根的子女依旧是最大堆,二新交换的根元素很有可能违背最大堆的性质。这时调用MaxHeap重新调整一下。在a[1-(n-1)]中构造出最大堆。堆排序不断重复这一过程,堆的大小由n-1一直降到2.从而完成排序的功能

[cpp] view plaincopy
 
  1. //堆排序  
  2. int HeapSort(int a[],int n){  
  3.     int temp;  
  4.     //BulidMaxHeap将输入数组构造一个最大堆  
  5.     BuildMaxHeap(a,n);  
  6.     //数组中最大元素在根a[1],则可以通过它与a[n]交换来达到最终的正确位置  
  7.     for(int i = n;i >= 2;i--){  
  8.         //交换  
  9.         temp = a[i];  
  10.         a[i] = a[1];  
  11.         a[1] = temp;  
  12.         //a[i]已达到正确位置,从堆中去掉  
  13.         n--;  
  14.         //重新调整,保持最大堆的性质  
  15.         MaxHeap(a,1,n);  
  16.     }  
  17.     return 0;  
  18. }  



 

                          (a)                                                   (b)                                               (c)                                                (d)

                        (e)                                                    (f)                                                    (g)

                             (h)                                              (i)                                                  (j)                                                (k)

 

红色为排序后的结果;

代码:

[cpp] view plaincopy
 
    1. #include<stdio.h>  
    2. #include<stdlib.h>  
    3.   
    4. //调整堆  
    5. int MaxHeap(int a[],int index,int n){  
    6.     int LargestIndex = index;  
    7.     //左子节点  
    8.     int LeftIndex = 2*index;  
    9.     //右子节点  
    10.     int RightIndex = 2*index+1;  
    11.     if(LeftIndex <= n && a[LeftIndex] > a[LargestIndex]){  
    12.         LargestIndex = LeftIndex;  
    13.     }  
    14.     if(RightIndex <= n && a[RightIndex] > a[LargestIndex]){  
    15.         LargestIndex = RightIndex;  
    16.     }  
    17.     //如果a[index]是最大的,则以index为根的子树已是最大堆否则index的子节点有最大元素  
    18.     //则交换a[index],a[LargetIndex],从而使index及子女满足堆性质  
    19.     int temp;  
    20.     if(LargestIndex != index){  
    21.         //交换a[index],a[LargetIndex]  
    22.         temp = a[index];  
    23.         a[index] = a[LargestIndex];  
    24.         a[LargestIndex] = temp;  
    25.         //重新调整以LargestIndex为根的子树  
    26.         MaxHeap(a,LargestIndex,n);  
    27.     }  
    28.     return 0;  
    29. }  
    30.   
    31.   
    32. //建堆:将一个数组a[1-n]变成一个最大堆  
    33. int BuildMaxHeap(int a[],int n){  
    34.     int i;  
    35.     //子数组a[(n/2+1,n/2+2......n)]中的元素都是树中的叶子  
    36.     for(i = n/2;i >= 1;i--){  
    37.         //调整以i为根节点的树使之成为最大堆  
    38.         MaxHeap(a,i,n);  
    39.     }  
    40.     return 0;  
    41. }  
    42.   
    43. //堆排序  
    44. int HeapSort(int a[],int n){  
    45.     int temp;  
    46.     //BulidMaxHeap将输入数组构造一个最大堆  
    47.     BuildMaxHeap(a,n);  
    48.     //数组中最大元素在根a[1],则可以通过它与a[n]交换来达到最终的正确位置  
    49.     for(int i = n;i >= 2;i--){  
    50.         //交换  
    51.         temp = a[i];  
    52.         a[i] = a[1];  
    53.         a[1] = temp;  
    54.         //a[i]已达到正确位置,从堆中去掉  
    55.         n--;  
    56.         //重新调整,保持最大堆的性质  
    57.         MaxHeap(a,1,n);  
    58.     }  
    59.     return 0;  
    60. }  
    61. int main(){  
    62.     int n = 6;  
    63.     //a[0]不用,堆的根结点是从1开始的  
    64.     int a[] = {0,3,17,8,7,16,20};  
    65.     HeapSort(a,n);  
    66.     for(int i = 1;i <= n;i++){  
    67.         printf("%d ",a[i]);  
    68.     }  
    69.     return 0;  
    70. }  
posted @ 2015-10-09 20:18  小东瓜刨冰  阅读(151)  评论(0编辑  收藏  举报