首页 > 代码库 > 经典白话算法之堆排序

经典白话算法之堆排序

2024-07-02 10:14:41   231人阅读

前序：

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

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

树的根为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数组

167320178
初始堆：

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

                       （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. }  

经典白话算法之堆排序


联系
我们