算法——排序之堆排序

堆排序是一种基于堆的排序。要了解堆排序，首先我们要了解堆的特性。

那么什么是堆呢？

这里我们使用大顶堆，并且是二叉堆，且用数组实现的方式作为例子。

在二叉堆的数组中，每个元素都要保证大于等于两个特定位置的元素，这里所说的特定位置，在树结构中就是它的子节点。所有节点都要满足上面所说的情况。如果我们画成二叉树的形式，我们就很容易理解了。

可以看到，如果满足上面的特点的话，那么树的根节点的元素的值一直是最大的，这就是大顶堆。同样的也有小顶堆，根节点的元素是最小的。

而对于数组实现的二叉堆来说，他们的父子关系非常容易确认。我们设数组中a[1]为根节点。那么他的子节点就是2，3。对于某个节点k呢？他的子节点就是2*k和2*k+1。父节点就是k/2。当然这需要我们将数组a[1]作为根节点，而不是用a[0]。用a[0]也可以，但是父子节点关系没这么简单而已，不过也差不了多少。习惯上用a[1]作为根节点。我们这里也采用这种方式。

看到这个结构，有没有对使用堆结构的排序有一种恍然大悟的想法呢？

对，我们可以使用堆结构来优化我们的选择排序。因为选择排序每一轮就是找到最大的元素，然后固定位置。而堆结构能够非常快速的给我们他的最大值。这样，他一直给我们提供最大值的话，我们就可以轻而易举的完成选择排序了！

不过我们首先要了解的是，如何建立一个堆。还需要了解建立这个堆，以及这个堆给我们提供最大值的效率是多少？如果建立这个堆花费代价很大，并且给我们提供最大值也需要很大的代价的话，上面提到的就完全没有意义了。幸运的是，建立堆，并且获取最大值代价并不大。

给我们一个数组，我们怎么样可以使得这个数组是一个二叉堆呢？

我们采用下沉的办法。我们假设原本这个是一个堆结构，但是突然，其中一个元素之改变了，那么我们如何将这个堆结构重新维护起来呢？

如图所示：除了下沉的节点之外，其他的节点已经满足堆结构的要求。

对于叶节点我们不需要管，我们只需要遍历所有不是叶节点的节点，让他们下沉。因为我们认为只有叶节点，已经是一个堆结构了。这样，从后向前，因为后面的永远是一个堆结构，每次我们只对一个元素进行定位，也就是下沉，就能够将堆建立起来。

这样，当我们下沉完毕的时候，这个堆就创建好了。

堆我们已经创建好了，那么我们如何利用他进行排序呢？

我们采用这个思路：每次将最大的元素和数组末尾的元素进行位置的交换。

但是将数组末尾的元素放在根节点上，堆结构就被破坏了。所以我们需要重新维护这个堆。因为我们除了根节点和数组末尾的元素之外，其他地方都已经是一个堆结构了。所以我们可以将交换上来的，新的根节点下沉。当然，这个时候建立堆的数组就应该缩小了，应该将数组末尾的元素剔除，也就是数组的大小减一。这样才能满足除了根节点之外，数组已经是一个堆的这么一个前提。

当我们慢慢的将根节点的元素放到数组的末尾去，因为根节点的元素永远是当前数组中最大的，所以我们就可以从后向前慢慢的排序起来。

如图所示：

代码如下：

public static void sort(Comparable[] a) {
	// 先构造堆
	int N = a.length;
	for (int i = N / 2; i >= 1; i--) {
		sink(a, i, N);
	}
	// 排序，销毁堆
	while (N-- > 1) {
		swap(a, 1, N);
		sink(a, 1, N);
	}
}

public static void sink(Comparable[] a, int begin, int length) {
	while (begin * 2 < length) {
		int maxIndex = begin * 2;
		if (maxIndex + 1 < length && less(a[maxIndex], a[maxIndex + 1])) { // 如果有两个子节点,选择较大的子节点
			maxIndex++;
		}

		if (!less(a[begin], a[maxIndex]))
			break;
		swap(a, begin, maxIndex);
		begin = maxIndex;
	}
}

当堆已经存在的时候，我们插入一个元素所需时间为O(logN)。我们需要插入N/2个元素。所以堆排序的时间复杂度是O(nlogn)。

而对于空间复杂度，我们以外的发现，堆排序的空间复杂度仅仅为O(1)，并且它最坏复杂度也是O(nlogn)。

时间复杂度达到了下限，空间复杂度也是常数级别的。那么是不是意味着堆排序超6，碾压其他算法呢？

但我们的应用一般都不会使用堆排序，用的最多的还是快排，为什么呢？

我们先来比较一下归并排序，快速排序，堆排序的效率：

public static void main(String[] args) {
	final int NUM = 1000000;
	Integer[] a1 = new Integer[NUM];
	Integer[] a2 = new Integer[NUM];
	Integer[] a3 = new Integer[NUM];
	Integer[] a4 = new Integer[NUM];
	a1[0] = a2[0] = a3[0] = a4[0] = -1;
	for (int i = 1; i < NUM; i++) {
		a1[i] = (int) (Math.random() * NUM);
		a2[i] = a1[i];
		a3[i] = a1[i];
		a4[i] = a1[i];
	}

	long startTime;
	long endTime;
	
	startTime = System.currentTimeMillis(); // 获取开始时间
	QuickSort.sort2(a2);
	assert isSorted(a2);
	endTime = System.currentTimeMillis();
	System.out.println("Quick排序cost: " + (endTime - startTime) + " ms");
	
	startTime = System.currentTimeMillis(); // 获取开始时间
	MergeSort.sort2(a3);
	assert isSorted(a3);
	endTime = System.currentTimeMillis();
	System.out.println("Merge排序cost: " + (endTime - startTime) + " ms");
	
	startTime = System.currentTimeMillis(); // 获取开始时间
	HeapSort.sort(a1);
	assert isSorted(a1);
	endTime = System.currentTimeMillis();
	System.out.println("Heap排序cost: " + (endTime - startTime) + " ms");
}

我们改变一下数组大小。

当数组大小为1000时：

Quick排序cost: 4 ms
Merge排序cost: 2 ms
Heap排序cost: 1 ms

数组大小为10000时：

Quick排序cost: 10 ms
Merge排序cost: 9 ms
Heap排序cost: 10 ms

数组大小为100000时：

Quick排序cost: 79 ms
Merge排序cost: 85 ms
Heap排序cost: 121 ms

数组大小为1000000时：

Quick排序cost: 421 ms
Merge排序cost: 470 ms
Heap排序cost: 929 ms

我们发现，当数组越来越大的时候，堆排序的效率就被慢慢拉开了。这是为什么呢？

这是由于计算机缓存的原因。因为在堆排序中，数组很少会和相邻的元素进行比较，这对于现代操作系统来说，就不是一个很好的东西了。因为它的缓存命中概率很小。在需要排序的数组很小的时候，可以一次把数组都读到缓存中，这就和快排，归并排序差不多。但是当数组变大的时候，就不能把数组都放到缓存中了，所以效率一下子就低下来了。在这点上，数组大了之后，甚至还比不过希尔排序。快排之所以快，其中一点非常重要的原因就是因为命中率极高。

但这是不是意味着堆排序没卵用呢？

也不是这样的，在没有多少缓存，并且不能给我们提供很大的空间的时候，堆排序就非常有用了。例如在嵌入式系统中，堆排序是重要的排序手段。

而且用堆实现的优先队列在很多应用中都是广为使用的。