堆是数据结构中的一种重要结构，了解了“堆”的概念和操作，可以快速掌握堆排序。

堆的概念

堆是一种特殊的完全二叉树(complete binary tree)。如果一棵完全二叉树的所有节点的值都不小于其子节点，称之为大根堆(或大顶堆)；所有节点的值都不大于其子节点，称之为小根堆(或小顶堆)。

在数组(在0号下标存储根节点)中，容易得到下面的式子(这两个式子很重要)：

1.下标为i的节点，父节点坐标为(i-1)/2；

2.下标为i的节点，左子节点坐标为2*i+1，右子节点为2*i+2。

堆的建立和维护

堆可以支持多种操作，但现在我们关心的只有两个问题：

1.给定一个无序数组，如何建立为堆？

2.删除堆顶元素后，如何调整数组成为新堆？

先看第二个问题。假定我们已经有一个现成的大根堆。现在我们删除了根元素，但并没有移动别的元素。想想发生了什么：根元素空了，但其它元素还保持着堆的性质。我们可以把最后一个元素(代号A)移动到根元素的位置。如果不是特殊情况，则堆的性质被破坏。但这仅仅是由于A小于其某个子元素。于是，我们可以把A和这个子元素调换位置。如果A大于其所有子元素，则堆调整好了；否则，重复上述过程，A元素在树形结构中不断“下沉”，直到合适的位置，数组重新恢复堆的性质。上述过程一般称为“筛选”，方向显然是自上而下。

删除一个元素是如此，插入一个新元素也是如此。不同的是，我们把新元素放在末尾，然后和其父节点做比较，即自下而上筛选。

那么，第一个问题怎么解决呢？

我看过的数据结构的书很多都是从第一个非叶子结点向下筛选，直到根元素筛选完毕。这个方法叫“筛选法”，需要循环筛选n/2个元素。

但我们还可以借鉴“无中生有”的思路。我们可以视第一个元素为一个堆，然后不断向其中添加新元素。这个方法叫做“插入法”，需要循环插入(n-1)个元素。

由于筛选法和插入法的方式不同，所以，相同的数据，它们建立的堆一般不同。

大致了解堆之后，堆排序就是水到渠成的事情了。

算法概述/思路

我们需要一个升序的序列，怎么办呢？我们可以建立一个最小堆，然后每次输出根元素。但是，这个方法需要额外的空间(否则将造成大量的元素移动，其复杂度会飙升到O(n^2))。如果我们需要就地排序(即不允许有O(n)空间复杂度)，怎么办？

有办法。我们可以建立最大堆，然后我们倒着输出，在最后一个位置输出最大值，次末位置输出次大值……由于每次输出的最大元素会腾出第一个空间，因此，我们恰好可以放置这样的元素而不需要额外空间。很漂亮的想法，是不是？

下面是堆排序的示意图(图片来自维基百科)：

代码实现

由于堆是一种数据结构，因此，我们可以封装它为一个类。当然，也可以不这么做。下面的代码使用筛选法建立了一个堆。

package flyingcat.sort;

/**

*

* @author FlyingCat

* Date: 2013-8-26

*

*/

public class ArrayHeap {

private int[] array;

public ArrayHeap(int[] arr) {

this.array = arr;

}

private int getParentIndex(int child) {

return (child - 1) / 2;

}

private int getLeftChildIndex(int parent) {

return 2 * parent + 1;

}

/**

* 初始化一个大根堆。

*/

private void initHeap() {

int last = array.length - 1;

for (int i = getParentIndex(last); i >= 0; --i) { // 从最后一个非叶子结点开始筛选

int k = i;

int j = getLeftChildIndex(k);

while (j <= last) {

if (j < last) {

if (array[j] <= array[j + 1]) { // 右子节点更大

j++;

}

}

if (array[k] > array[j]) { //父节点大于子节点中较大者，已经找到最终位置

break; // 停止筛选

} else {

swap(k, j);

k = j; // 继续筛选

}

j = getLeftChildIndex(k);

}// loop while

}// loop i

}

/**

* 调整堆。

*/

private void adjustHeap(int lastIndex) {

int k = 0;

while (k <= getParentIndex(lastIndex)) {

int j = getLeftChildIndex(k);

if (j < lastIndex) {

if (array[j] < array[j + 1]) {

j++;

}

}

if (array[k] < array[j]) {

swap(k, j);

k = j; // 继续筛选

} else {

break; // 停止筛选

}

}

}

/**

* 堆排序。

* */

public void sort() {

initHeap();

int last = array.length - 1;

while (last > 0) {

swap(0, last);

last--;

if (last > 0) { // 这里如果不判断，将造成最终前两个元素逆序。

adjustHeap(last);

}

}

}

private void swap(int i, int j) {

int temp = array[i];

array[i] = array[j];

array[j] = temp;

}

}

算法性能/复杂度

堆排序的时间复杂度非常稳定(我们可以看到，对输入数据不敏感)，为O(n㏒n)复杂度，最好情况与最坏情况一样。

但是，其空间复杂度依实现不同而不同。上面即讨论了两种常见的复杂度：O(n)与O(1)。本着节约空间的原则，我推荐O(1)复杂度的方法。

算法稳定性

堆排序存在大量的筛选和移动过程，属于不稳定的排序算法。

算法适用场景

堆排序在建立堆和调整堆的过程中会产生比较大的开销，在元素少的时候并不适用。但是，在元素比较多的情况下，还是不错的一个选择。尤其是在解决诸如“前n大的数”一类问题时，几乎是首选算法。

参考资料