heap sort分析和总结

heap sort分析和总结

文章转自：http://shmilyaw-hotmail-com.iteye.com/blog/1775868 

简介

        关于堆排序的文章，可以说网上一搜就有一大堆。有的时候自己都在想有没有写这个的必要。仔细看看网上的一些文章，很多不外乎一上来就直接堆代码，让人看的云里雾里。有的则是讲的比较笼统，让人很难懂。于是就想根据自己学习思考的经历，尽量用一种容易理解的方式整理出来。也当是一种学习总结吧。

 

关于堆

        一般我们看到堆这个词，总会想到那些分配对象存储等复杂的数据结构。在堆排序里，很直白的来说，堆就是一个简单的数组。只是我们用一种完全二叉树的角度来看它。以最大堆为例，比如说我们有一棵如下的二叉树：

 

从上图中，我们发现，如果我们从根结点开始按照从左到右一层一层的编号的话，对这些元素的访问就构成了一个序列。比如上图中的序列按照编号顺序如下：16, 14, 10, 8, 7, 9, 3, 2, 4, 1

如果我们将这种从二叉树的结点关系转换成对应的数组形式的话，则对应的数组如下图：

 

        从二叉树的每个结点的编码到它的左右字结点的关系，我们发现一个有意思的地方：

左子结点的编号=父结点编号 * 2 

右子结点的编号=父结点编号 * 2 + 1

 按照数组标的编号，有类似的对应关系：

左子结点的数组索引号= 父结点索引号 * 2

右子结点的数组索引号=父结点索引号 * 2 + 1

 

    这样，我们通过一定的运算对应关系将二叉树关系的元素存储到一个数组中。针对以上的父子结点关系，他们对应的求法可以用一下几个方法实现：left(), right()。在实现的时候考虑到我们的数组下标是从0开始的，对应的关系修改为：

left(n) = n * 2 + 1   right(n) = n * 2 + 2

对应的代码实现如下：

left:

Java代码  

1. public static int left(int i)  
2. {  
3.     return i * 2 + 1;  
4. }  

 right:

Java代码  

1. public static int right(int i)  
2. {  
3.     return i * 2 + 2;  
4. }  

调整堆

     ok，前面我们已经理解了堆和对应的数组之间的关系了。再来考虑另外一个问题。我们假定是要建立一个最大堆。那么对于这么一个最大堆来说，它有一个重要的特性就是处于父结点的值必须比它的子结点要大。假设某一棵树上面的父结点不满足这个要求，我们就必须进行调整。笼统的说，调整就是将这个不符合条件的结点和子结点进行比较，通过交换将最大的结点作为父结点。具体的流程见下图：

        在上图中，我们发现值为4的结点不符合要求。那么就需要进行交换调整。接着就需要在它的两个子结点中选择最大的那个，然后交换位置。它的子结点中最大的是14.交换之后的结果如下图：

 

经过交换之后，我们发现原来元素所在的位置确实符合要求了。可是4交换到新的结点之后又不符合最大堆的条件了。没办法，还需要继续选择最大子结点进行交换。这么一交换之后的结果如下：

    经过这么两轮交换，我们终于可以保证以i = 2这个结点为根的树最终达到了一个符合最大堆的状态。总结前面这么一个交换调整的过程，主要如下：

1. 比较当前结点和它的子结点，如果当前结点小于它的任何一个子结点，则和最大的那个子结点交换。否则，当前过程结束。

2. 在交换到新位置的结点重复步骤1，直到叶结点。

    对上面的过程进行细化之后编码，我们可以得到两个版本的方法：

递归版本：

Java代码  

1. public static void maxHeapify(int[] a, int i)  
2. {  
3.     int l = left(i);  
4.     int r = right(i);  
5.     int largest = i;  
6.   
7.     if(l < a.length && a[l] > a[i])  
8.         largest = l;  
9.     if(r < a.length && a[r] > a[largest])  
10.         largest = r;  
11.     if(i != largest)  
12.     {  
13.         swap(a, i, largest);  
14.         maxHeapify(a, largest);  
15.     }  
16. }  

 

 非递归版本：

Java代码  

1. public static void maxHeapify(int[] a, int i)  
2. {  
3.     int l = left(i);  
4.     int r = right(i);  
5.     int largest = i;  
6.     while(true)  
7.     {  
8.         if(l < a.length && a[l] > a[i])  
9.             largest = l;  
10.         if(r < a.length && a[r] > a[largest])  
11.             largest = r;  
12.         if(i != largest)  
13.             swap(a, i, largest);  
14.         else  
15.             break;  
16.         i = largest;  
17.         l = left(largest);  
18.         r = right(largest);  
19.     }  
20. }  

    以上两个版本的实现主要有几个要点要注意：1. 每次求一个结点的子结点的时候要检查是否越界。 2. 每次通过将当前结点和子结点的比较来选取最大值，如果最大值就是当前结点，则程序返回。 3. 里面的swap方法就是交换两个索引位置元素的位置，因为比较简单就在此省略了。

建最大堆

    我们注意到，前面虽然有一个堆调整的过程，但是这个过程主要针对的是一个树中的一个结点。如果树中间有多个结点不符合最大堆的条件，我们光调整某一个结点是没有用的。那么，就需要一个办法来将整棵树调整成符合条件的最大堆。

    一个最简单的办法就是从最低层的结点开始起调整。很明显，如果我们从a[a.length -1]这样的结点来调整的话，有相当一部分结点是没必要的。因为这些结点很显然是叶结点，也就是说他们根本就没有子结点，连找子结点和去比较的必要都没有了。所以，我们可以从最后面往前到过来去找那些有子结点的结点，然后从这些结点开始一个个的进行堆调整。那么，我们该从哪个结点开始起进行调整呢？另外，我们可能还有这么一个疑问，为什么我们要从后面往前去调整？从前面往后调整不行吗？别急，让我们一个个的来分析。

     首先第一个问题，从哪个结点开始进行调整。我们来看这棵二叉树，很显然，它最后的一个元素也肯定就是最终的一个叶结点。那么取它的父结点应该就是有子结点的最大号的元素了。那么从它开始就是最合适的。取它的父结点可以通过一个简单的i / 2来得到，i为当前结点的下标。

    然后我们再来看第二个问题，为什么要从后往前而不是从前往后。这个相对也比较好理解。我们从下面的层开始调整，保证当上面的父结点来调整的时候，下面的子树已经满足最大堆的条件了。这样出现不符合条件的父结点只需要用前面的maxheapify过程就可以。而从前面往后调整呢，我们看下面的一个示例：

    如果我们从根结点开始，根结点元素4比它的两个子结点都大，不需要调整。而再往后面的时候它的子结点1调整之后被换成16.这样就出现了它的子结点比它还要大的情况，因此从前往后这么调整的过程不行。

    经过前面的讨论，构建最大堆的过程就相当的简单了：

Java代码  

1. public static void buildMaxHeap(int[] a)  
2. {  
3.     for(int i = a.length / 2; i >= 0; i--)  
4.         maxHeapify(a, i);  
5. }  

     总的来说，建立最大堆的过程无非就是要建立一个符合如下条件的二叉树：它所有的结点值都比它的子结点要大。

拼在一起

     好了，有了前面扯的基础，再来看怎么排序就很好理解了。既然我通过建了一个最大堆，能够保证最大的元素就是根结点，那么，我们如果要从小到大排序的话，最大的元素就只要取根结点就可以了。如果我们把根结点拿走了，放到结果集的最末一个元素，接着就应该找第二大的元素。因为要保证这棵树本身是近似完全二叉树的性质，我们不能把中间的结点直接挪到根结点来比较。但是前面的maxHeapify过程提醒我们，如果我们从集合的最低一层叶结点来取，然后放到根结点进行调整的话，肯定也是可以得到剩下元素里面的最大结点的。就这样，我们可以得到这么一个过程：

1. 取最大堆的根结点元素。

2. 取集合最末尾的元素，放到根结点，调用maxHeapify进行调整。重复步骤1.

    在具体实现的时候我们可以发现，每次都要取集合中后面的元素，我们原来得到的最大结点正好可以放到集合的末尾，正好达到最大的元素放到最后的效果。

    实现堆排序的临门一脚如下：

Java代码  

1. public static void heapSort(int[] a)  
2. {  
3.     if(a == null || a.length <= 1)  
4.         return;  
5.   
6.     buildMaxHeap(a);  
7.     int length = a.length;  
8.     for(int i = a.length - 1; i > 0; i--)  
9.     {  
10.         swap(a, i, 0);  
11.         length--;  
12.         maxHeapify(a, 0, length);  
13.     }  
14. }  

    仔细看前面的代码，大家可能会发现一个细小的改变。就是maxHeapify方法多了个参数。这是因为考虑到实际情况下，如果每次我们把找到的当前集合最大元素放到后面了，那么这些元素就相当于从前面的集合中排除出来，后面进行堆调整的时候就不需要再考虑。所以用一个length的长度来限制调整的范围，以免伤及无辜：）。具体的实现可以看后面附件里的详细实现代码。

总结

        堆排序粗看起来有好多个步骤，又是要建堆又是要调整的显得很复杂。其实它的过程概括起来无非就是这么两个步骤，一个就是建一个堆，然后就是每次取走根结点的元素用后面的来补，补上后进行调整，然后再重复前面的步骤。

参考资料

Introduction to algorithms

一步一步写算法（之堆排序）