Java排序算法总结(六):堆排序

开发 后端 算法
1991年计算机先驱奖获得者、斯坦福大学计算机科学系教授罗伯特·弗洛伊德(Robert W.Floyd)和威廉姆斯(J.Williams)在1964年共同发明了著名的堆排序算法( Heap Sort )。本文主要介绍堆排序用Java来实现。

堆积排序(Heapsort)是指利用堆积树(堆)这种资料结构所设计的一种排序算法,可以利用数组的特点快速定位指定索引的元素。堆排序是不稳定的排序方法,辅助空间为O(1), 最坏时间复杂度为O(nlog2n) ,堆排序的堆序的平均性能较接近于最坏性能。 

堆排序利用了大根堆(或小根堆)堆顶记录的关键字***(或最小)这一特征,使得在当前无序区中选取***(或最小)关键字的记录变得简单。

(1)用大根堆排序的基本思想

① 先将初始文件R[1..n]建成一个大根堆,此堆为初始的无序区

② 再将关键字***的记录R[1](即堆顶)和无序区的***一个记录R[n]交换,由此得到新的无序区R[1..n-1]和有序区R[n],且满足R[1..n-1].keys≤R[n].key

③由于交换后新的根R[1]可能违反堆性质,故应将当前无序区R[1..n-1]调整为堆。然后再次将R[1..n-1]中关键字***的记录R[1]和该区间的***一个记录R[n-1]交换,由此得到新的无序区R[1..n-2]和有序区R[n-1..n],且仍满足关系R[1..n-2].keys≤R[n-1..n].keys,同样要将R[1..n-2]调整为堆。

……

直到无序区只有一个元素为止。

(2)大根堆排序算法的基本操作: 

① 初始化操作:将R[1..n]构造为初始堆;

② 每一趟排序的基本操作:将当前无序区的堆顶记录R[1]和该区间的***一个记录交换,然后将新的无序区调整为堆(亦称重建堆)。

注意: 

①只需做n-1趟排序,选出较大的n-1个关键字即可以使得文件递增有序。

②用小根堆排序与利用大根堆类似,只不过其排序结果是递减有序的。堆排序和直接选择排序相反:在任何时刻堆排序中无序区总是在有序区之前,且有序区是在原向量的尾部由后往前逐步扩大至整个向量为止。

代码实现:

  1. public class Test {   
  2. public static int[] Heap = { 1032195712043 }; // 预设数据数组   
  3. public static void main(String args[]) {   
  4. int i; // 循环计数变量   
  5. int Index = Heap.length; // 数据索引变量   
  6. System.out.print("排序前: ");   
  7. for (i = 1; i < Index - 1; i++)   
  8. System.out.printf("%3s", Heap);   
  9. System.out.println("");   
  10. HeapSort(Index - 2); // 堆排序   
  11. System.out.print("排序后: ");   
  12. for (i = 1; i < Index - 1; i++)   
  13. System.out.printf("%3s", Heap);   
  14. System.out.println("");   
  15. }   
  16. /**   
  17. * 建立堆   
  18. */   
  19. public static void CreateHeap(int Root, int Index) {   
  20. int i, j; // 循环计数变量   
  21. int Temp; // 暂存变量   
  22. int Finish; // 判断堆是否建立完成   
  23. j = 2 * Root; // 子节点的Index   
  24. Temp = Heap[Root]; // 暂存Heap的Root 值   
  25. Finish = 0// 预设堆建立尚未完成   
  26. while (j <= Index && Finish == 0) {   
  27. if (j < Index) // 找***的子节点   
  28. if (Heap[j] < Heap[j + 1])   
  29. j++;   
  30. if (Temp >= Heap[j])   
  31. Finish = 1// 堆建立完成   
  32. else {   
  33. Heap[j / 2] = Heap[j]; // 父节点 = 目前节点   
  34. j = 2 * j;   
  35. }   
  36. }   
  37. Heap[j / 2] = Temp; // 父节点 = Root值   
  38. }   
  39. public static void HeapSort(int Index) {   
  40. int i, j, Temp;   
  41. // 将二叉树转成Heap   
  42. for (i = (Index / 2); i >= 1; i--)   
  43. CreateHeap(i, Index);   
  44. // 开始进行堆排序   
  45. for (i = Index - 1; i >= 1; i--) {   
  46. Temp = Heap; // Heap的Root值和***一个值交换   
  47. Heap = Heap[1];   
  48. Heap[1] = Temp;   
  49. CreateHeap(1, i); // 对其余数值重建堆   
  50. System.out.print("排序中: ");   
  51. for (j = 1; j <= Index; j++)   
  52. System.out.printf("%3s",Heap[j]);   
  53. System.out.println("");   
  54. }   
  55. }   

堆可以被看成是一棵树,结点在堆中的高度可以被定义为从本结点到叶子结点的最长简单下降路径上边的数目;定义堆的高度为树根的高度。我们将看到,堆结构上的一些基本操作的运行时间至多是与树的高度成正比,为O(lgn)。通过阅读本文,希望能帮助到你。

【编辑推荐】

  1. 关于java数组的深度思考
  2. Java架构设计和开发中的小技巧
  3. Java编程解析节省内存效率高的方法
  4. Javascript解决浏览器兼容性问题

 

责任编辑:于铁 来源: 百度
相关推荐

2021-01-19 07:02:26

算法数据结构堆排序

2014-10-30 15:59:10

2011-04-20 14:07:37

冒泡排序

2011-04-20 13:56:08

选择排序

2011-04-20 14:19:00

希尔排序

2011-04-20 15:20:03

快速排序

2011-04-20 12:49:44

插入排序

2011-04-20 14:29:07

归并排序

2011-04-20 16:05:15

基数排序

2021-03-23 08:33:22

Java数据结构算法

2019-09-17 16:30:18

java排序算法

2015-08-26 10:13:55

排序算法总结

2023-10-10 08:00:07

2015-09-01 10:21:53

排序算法总结

2021-01-20 06:09:30

堆排序TopK应用场景

2023-10-05 09:01:05

插入排序对象序列log2i

2022-01-06 16:20:04

Java排序算法排序

2011-04-20 11:22:51

Java

2023-03-06 08:10:52

数据结构算法数据

2019-08-28 11:08:51

排序算法Java
点赞
收藏

51CTO技术栈公众号