实现堆排序

1. /**
2. * 22.实现堆排序
3. *
4. * */
5. public class HeapSort
6. {
7. private static int[] a = null;
9. public Test_22(int k)
10. {
11. a = new int[k];
12. for (int i = 0; i < a.length; i++)
13. {
14. int temp = (int) (Math.random() * 100);
15. System.out.print(temp + " ");
16. a[i] = temp;
17. }
18. System.out.println();
20. swap(a, 1, 2);
21. System.out.println(Arrays.toString(a));
22. }
24. public static void main(String[] args)
25. {
26. Test_22 test = new Test_22(22);
27. test.deepsort(a, 0, 21);
28. System.out.println(Arrays.toString(a));
29. }
31. private void deepsort(int[] a, int star, int end)
32. {
33. // 1,建堆，大顶堆
34. // 2.排队，即把堆顶大数移动到数组后面位置
35. for (int i = 0; i < a.length - 1; i++)
36. {
37. buildDeep(a, a.length - i);
38. swap(a, 0, a.length - 1 - i);
39. }
41. }
43. static private void buildDeep(int[] a, int length)
44. {// 堆的高度
46. // 从尾巴开始比较，定义一个指针 指向最后的父亲节点
47. // 首先，2个叶子比较，然后大的叶子和父亲节点比较，如果父亲大 则不操作 指针向前面走一位
48. // 如果子节点比父亲大 父亲与子节点交换 指针指向该交换后的子节点位子
49. // 當指針指向根位子的前一個位子 則退出循環
50. int p = (length - 2) / 2;
51. while (p >= 0)
52. {
54. // 如果左子节点存在
55. while (p * 2 + 1 < length)
56. {// 默认左子节点是最大的
57. int max = p * 2 + 1;
58. // 如果右子节点存在
59. if ((p + 1) * 2 < length)
60. {
61. // 比较左右子节点
62. if (a[(p + 1) * 2] > a[max])
63. {
64. max = (p + 1) * 2;
65. }
66. }
67. // 比较最大子节点与父亲节点
68. if (a[p] < a[max])
69. {// 最大子节点与父亲节点的值交换，并且指针p指向max
70. swap(a, max, p);
71. p = max;
72. } else
73. {
74. break;
75. }
76. }
77. p--;
78. }
79. }
80. /***
81. * 数组中某2个位置的值交换
82. *
83. * @param a
84. * 数组
85. * @param star
86. * 待交换的第一个位子
87. * @param end
88. * 待交换的第二个位子
89. * */
90. private static void swap(int[] a, int star, int end)
91. {
92. int temp = a[end];
93. a[end] = a[star];
94. a[star] = temp;
95. }
96. }

null