Java与算法之(8) - 堆排序

堆是一种特殊的完全二叉树，其特点是所有父节点都比子节点要小，或者所有父节点都比字节点要大。前一种称为最小堆，后一种称为最大堆。

比如下面这两个：

那么这个特性有什么作用？既然题目是堆排序，那么肯定能用来排序。想要用堆排序首先要创建一个堆，如果对4 3 6 2 7 1 5这七个数字做从小到大排序，需要用这七个数创建一个最大堆，来看代码：

1. public class HeapSort {
2. private int[] numbers;
3. private int length;
4. public HeapSort(int[] numbers) {
5. this.numbers = numbers;
6. this.length = numbers.length;
7. }
8. /**
9. * 调整二叉树
10. * 如果父节点编号为x, 那么左子节点的编号是2x, 右子节点的编号是2x+1
11. * 节点编号从1开始, 对应数组中的索引是编号-1
12. * @param nodeId 节点编号, 从1开始
13. */
14. public void adjust(int nodeId) {
15. int swapId;
16. int flag = 0; //是否需要继续向下调整
17. while(nodeId * 2 <= this.length && flag == 0) {
18. //首先判断它和左子节点的关系, 并用swapId记录值较小的节点编号(最大堆是记录较大的)
19. int index = nodeId - 1; //节点对应数组中数字的索引
20. int leftChild = nodeId * 2 - 1; //左子节点对应数组中数字的索引
21. int rightChild = nodeId * 2; //右子节点对应数组中数字的索引
22. if(numbers[index] < numbers[leftChild])  {
23. swapId = nodeId * 2;
24. } else {
25. swapId = nodeId;
26. }
27. //如果有右子节点, 再与右子节点比较
28. if(nodeId * 2 + 1 <= this.length) {
29. if(numbers[swapId - 1] < numbers[rightChild])
30. swapId = nodeId * 2 + 1;
31. }
32. //如果最小的节点编号不是自己, 说明子节点中有比父节点更小的
33. if(swapId != nodeId) {
34. swap(swapId, nodeId);
35. nodeId = swapId;
36. } else {
37. flag = 1;
38. }
39. }
40. }
41. /**
42. * 交换两个节点的值
43. * @param nodeId1
44. * @param nodeId2
45. */
46. public void swap(int nodeId1, int nodeId2) {
47. int t = numbers[nodeId1 - 1];
48. numbers[nodeId1 - 1] = numbers[nodeId2 - 1];
49. numbers[nodeId2 - 1] = t;
50. }
51. /**
52. * 创建最大堆
53. */
54. public void createMaxHeap() {
55. //从最后一个非叶节点到第一个节点依次向上调整
56. for(int i = this.length / 2; i >= 1; i--) {
57. adjust(i);
58. }
59. }
60. public static void main(String[] args) {
61. int[] numbers = new int[] { 4, 3, 6, 2, 7, 1, 5 };
62. for(int x = 0; x < numbers.length; x++) {
63. System.out.print(numbers[x] + "  ");
64. }
65. System.out.println();
66. HeapSort heap = new HeapSort(numbers);
67. heap.createMaxHeap();
68. }
69. }

对本例中的数列，从this.length / 2到1，共执行了三轮循环。

第一轮：

第二轮：

第三轮：

调整完成后，当前的二叉树已经符合最大堆的特性，可以用来从小到大排序。堆排序的原理是，交换堆顶和最后一个节点的数字，即把最大的数字放到数组最后，然后对除了最大数的前n-1个数从新执行调整过程，使其符合最大堆特性。重复以上过程直到堆中只剩下一个数字。

1. public void sort() {
2. while(this.length > 1) {
3. swap(1, this.length);
4. this.length--;
5. adjust(1);
6. }
7. for(int x = 0; x < numbers.length; x++) {
8. System.out.print(numbers[x] + "  ");
9. }
10. }

堆排序的时间复杂度和快速排序的平均时间复杂度一样，是O(nlogn)。