七大排序之:直接选择排序和堆排序

Posted Java开发小驿站

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了七大排序之:直接选择排序和堆排序相关的知识,希望对你有一定的参考价值。

上一篇总结了交换排序的冒泡排序和快速排序。这一篇要总结的是选择排序,选择排序分为直接选择排序和堆排序,主要从以下几点进行总结。

1、直接选择排序及算法实现

2、堆排序及算法实现

1、直接选择排序及算法实现

直接选择排序(Straight Select Sort) 是一种简单的排序方法,它的基本思想是:通过length-1 趟元素之间的比较,从length-i+1个元素中选出最小的元素,并和第i个元素交换位置。直接选择排序的最坏时间复杂度为O(n2),平均时间复杂度为O(n2)   

下图展示了直接选择排序的过程。

1-1、示意图

1-2、代码

SelectionSort.java

 
   
   
 
  1. public class SelectionSort {

  2. public static void main(String[] args) {

  3. int[] list = {9, 1, 2, 5, 7, 4, 8, 6, 3, 5};

  4. System.out.println("************直接选择排序************");

  5. System.out.println("排序前:");

  6. display(list);

  7. System.out.println("");


  8. System.out.println("排序后:");

  9. selectionSort(list);

  10. display(list);

  11. }


  12. /**

  13. * 直接选择排序算法

  14. */

  15. public static void selectionSort(int[] list) {

  16. // 要遍历的次数(length-1次)

  17. for (int i = 0; i < list.length - 1; i++) {

  18. // 将当前下标定义为最小值下标

  19. int min = i;


  20. // 遍历min后面的数据

  21. for (int j = i + 1; j <= list.length - 1; j++) {

  22. // 如果有小于当前最小值的元素,将它的下标赋值给min

  23. if (list[j] < list[min]) {

  24. min = j;

  25. }

  26. }

  27. // 如果min不等于i,说明找到真正的最小值

  28. if (min != i) {

  29. swap(list, min, i);

  30. }

  31. }

  32. }


  33. /**

  34. * 交换数组中两个位置的元素

  35. */

  36. public static void swap(int[] list, int min, int i) {

  37. int temp = list[min];

  38. list[min] = list[i];

  39. list[i] = temp;

  40. }


  41. /**

  42. * 遍历打印

  43. */

  44. public static void display(int[] list) {

  45. System.out.println("********展示开始********");

  46. if (list != null && list.length > 0) {

  47. for (int num :

  48. list) {

  49. System.out.print(num + " ");

  50. }

  51. System.out.println("");

  52. }

  53. System.out.println("********展示结束********");

  54. }

  55. }

测试结果:

七大排序之:直接选择排序和堆排序

2、堆排序及算法实现

堆排序(Heap Sort) 利用堆(一般为大根堆)进行排序的方法。它的基本思想是:将待排序的元素构造成一个大根堆。此时,整个序列的最大值就是堆顶的根节点。将它移走(其实就是将它与数组的末尾元素进行交换,此时末尾元素就是最大值),然后将剩余的length-1 个元素重新构造成一个大根堆,这样就会得到length个元素中的次大值。如此反复执行,便能得到一个有序的序列。

堆是具有下列性质的完全二叉树:每个节点的值都大于或等于其左右孩子节点的值,称为大根堆;每个节点的值都小于或等于其左右孩子节点的值,称为小根堆。

堆排序的最坏时间复杂度为O(n*log2n),平均时间复杂度为O(n*log2n)   

2-1、示意图

图一:

七大排序之:直接选择排序和堆排序

图二:

七大排序之:直接选择排序和堆排序

图三:

七大排序之:直接选择排序和堆排序

图四:

七大排序之:直接选择排序和堆排序

图五:

七大排序之:直接选择排序和堆排序

图六:

七大排序之:直接选择排序和堆排序

2-2、代码

HeapSort.java

 
   
   
 
  1. public class HeapSort {

  2. public static void main(String[] args) {

  3. int[] list = {1, 3, 4, 5, 2, 6, 9, 7, 8, 0};

  4. System.out.println("************堆排序************");

  5. System.out.println("排序前:");

  6. display(list);

  7. System.out.println("");


  8. System.out.println("排序后:");

  9. heapSort(list);

  10. display(list);

  11. }


  12. /**

  13. * 堆排序算法

  14. */

  15. public static void heapSort(int[] list) {

  16. // 将无序堆构造成一个大根堆,大根堆有length/2个父节点

  17. for (int i = list.length / 2 - 1; i >= 0; i--) {

  18. headAdjust(list, i, list.length);

  19. }


  20. // 逐步将每个最大值的根节点与末尾元素交换,并且再调整其为大根堆

  21. for (int i = list.length - 1; i > 0; i--) {

  22. // 将堆顶节点和当前未经排序的子序列的最后一个元素交换位置

  23. swap(list, 0, i);

  24. headAdjust(list, 0, i);

  25. }

  26. }


  27. /**

  28. * 构造大根堆

  29. */

  30. public static void headAdjust(int[] list, int parent, int length) {

  31. // 保存当前父节点

  32. int temp = list[parent];


  33. // 得到左孩子节点

  34. int leftChild = 2 * parent + 1;


  35. while (leftChild < length) {

  36. // 如果parent有右孩子,则要判断左孩子是否小于右孩子

  37. if (leftChild + 1 < length && list[leftChild] < list[leftChild + 1]) {

  38. leftChild++;

  39. }

  40. // 父亲节点大于子节点,就不用做交换

  41. if (temp >= list[leftChild]) {

  42. break;

  43. }

  44. // 将较大子节点的值赋给父亲节点

  45. list[parent] = list[leftChild];

  46. // 然后将子节点做为父亲节点

  47. parent = leftChild;

  48. // 找到该父亲节点较小的左孩子节点

  49. leftChild = 2 * parent + 1;

  50. }

  51. // 最后将temp值赋给较大的子节点,以形成两值交换

  52. list[parent] = temp;

  53. }


  54. /**

  55. * 交换数组中两个位置的元素

  56. */

  57. public static void swap(int[] list, int top, int last) {

  58. int temp = list[top];

  59. list[top] = list[last];

  60. list[last] = temp;

  61. }


  62. /**

  63. * 遍历打印

  64. */

  65. public static void display(int[] list) {

  66. System.out.println("********展示开始********");

  67. if (list != null && list.length > 0) {

  68. for (int num :

  69. list) {

  70. System.out.print(num + " ");

  71. }

  72. System.out.println("");

  73. }

  74. System.out.println("********展示结束********");

  75. }

  76. }

测试结果:


个人博客:https://www.cqwxhn.xin


以上是关于七大排序之:直接选择排序和堆排序的主要内容,如果未能解决你的问题,请参考以下文章

数据结构之七大排序算法

七大常见排序,你究竟懂几个?(上)

七大排序之:冒泡排序和快速排序

手机号码之基数排序

七大排序算法之选择排序

数据结构图解七大排序