排序问题（二）

原文地址：http://www.javawxs.com/index.php/sort-2/

上一篇谈了插入排序和希尔排序，这篇简单说说堆排序和归并排序；可能这两个排序算法不太容易掌握，不过通过自己多思考多实践，也肯定能熟练掌握的；以下是详细内容和程序代码。

堆排序

首先建立N个元素的二叉堆，花费时间（O(N)），然后执行N次的deleteMin操作。按照顺序，最小的元素先离开堆。通过将这些元素记录到第二个数组然后再将数组拷贝回来，得到N个元素的排序。由于每个deleteMin花费时间O(log N)，因此运行总时间为O(N log N)。

该算法的主要问题在于它使用了一个附加数组，增大大储存需求；可以这样来避免使用第二个数组：在每次deleteMin之后，堆缩小1；所以位于堆中最后的单元正好可以存放刚才删除的元素；最后一次deleteMin后，正好得到数组的递减排序。要想得到递增排序通过改变有序的特性使父亲的关键字的值大于儿子的关键字的值；就得到了(max)堆。

第一步以线性时间建立一个堆。然后通过每次将堆中的最后元素与第一个元素交换，执行N-1次deleteMin操作，每次将堆的大小缩减1并进行下滤。结束时，数组排序完成。

以下为代码：

1. package com.javawxs;
3. public class HeapSort {
4. private static int leftChild(int i) {
5. return 2 * i + 1;
6. }
8. private static <T extends Comparable<? super T>> void perDown(T[] a, int i,
9. int n) {
10. int child;
11. T tmp;
12. for (tmp = a[i]; leftChild(i) < n; i = child) {
13. child = leftChild(i);
14. if (child != n - 1 && a[child].compareTo(a[child + 1]) < 0)
15. child++;
16. if (tmp.compareTo(a[child]) < 0)
17. a[i] = a[child];
18. else
19. break;
20. }
22. a[i] = tmp;
23. }
25. private static <T extends Comparable<? super T>> void swapReferences(T[] a,
26. int i, int n) {
27. T temp = a[i];
28. a[i] = a[n];
29. a[n] = temp;
30. }
32. public static <T extends Comparable<? super T>> void heapSort(T[] a) {
33. for (int i = a.length / 2; i >= 0; i–)
34. perDown(a, i, a.length);
35. for (int i = a.length - 1; i > 0; i–) {
36. swapReferences(a, 0, i);
37. perDown(a, 0, i);
38. }
40. }
42. }

归并排序

下面谈一下归并排序。归并排序以O(N log N)最坏时间运行，而所使用的比较次数几乎是最优的，是递归算法的很好的例子。

这个排序算法基本的操作就是合并两个已排序的表，因为两个表已经完成排序，所以如果将输出结果放到第三个表中，则该算法可以通过对输入数据一趟排序来完成。基本的合并算法是取两个输入数组A、B，一个输出数组C，以及3个计数器Actr、Bctr、Cctr，它们初始置于对应数组的开始端。A[Actr]和B[Bctr]的较小的被拷贝到C的下一个位置，相关的计数器向前推进一步。当两个输入表有一个用完的时候，则将另一个表中剩余部分拷贝到C中。

归并排序很容易理解，就是递归地将前半部分和后半部分数据各自归并排序，得到排序后的两部分，然后用合并算法将两部分合并到一起。此算法采用了经典的分支策略，将问题

分成若干小问题然后递归求解，之后再将各小部分合在一起；以下代码是归并排序的一种实现：

1. package com.javawxs;
3. public class MergeSort {
5. private static <T extends Comparable<? super T>> void merge(T[] a,
6. T[] tmpArray, int leftPos, int rightPos, int rightEnd) {
7. int leftEnd = rightPos - 1;
8. int tmpPos = leftPos;
9. int numElements = rightEnd - leftPos + 1;
11. while (leftPos <= leftEnd && rightPos <= rightEnd) {
12. if (a[leftPos].compareTo(a[rightPos]) <= 0)
13. tmpArray[tmpPos++] = a[leftPos++];
14. else
15. tmpArray[tmpPos++] = a[rightPos++];
16. }
18. while (leftPos <= leftEnd)
19. tmpArray[tmpPos++] = a[leftPos++];
21. while (rightPos <= rightEnd)
22. tmpArray[tmpPos++] = a[rightPos++];
24. for (int i = 0; i < numElements; i++, rightEnd–)
25. a[rightEnd] = tmpArray[rightEnd];
26. }
28. private static <T extends Comparable<? super T>> void mergeSort(T[] a,
29. T[] tmpArray, int left, int right) {
30. if (left < right) {
31. int center = (left + right) / 2;
32. mergeSort(a, tmpArray, left, center);
33. mergeSort(a, tmpArray, center + 1, right);
34. merge(a, tmpArray, left, center + 1, right);
35. }
36. }
38. public static <T extends Comparable<? super T>> void mergeSort(T[] a) {
39. T[] tmpArray = (T[]) new Comparable[a.length];
40. mergeSort(a, tmpArray, 0, a.length - 1);
42. }
44. }