数据结构与算法——八大排序算法及总结（JAVA实现，图文详解）_java八大排序图解

1.冒泡排序

​ 比较相邻的元素。如果第一个比第二个大，就交换他们两个。对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。

​ 针对所有的元素重复以上的步骤，除了最后一个，即需要进行length-1次。

​ 第一次是对n个数进行n-1次比较，进行到最后第n个的一个是最大的；

​ 第二次是对n-1个数进行n-2次比较，进行到最后第n-1个的一个是最大的；

​ …

​ 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

/**
 * 冒泡排序，时间复杂度最高O(n²)，最佳时间复杂度是O(n)
 */
for (int i = 0; i < arr.length-1; i++) {
   
    for (int j = 0; j < arr.length - 1 - i; j++) {
   
        if (arr[j] > arr[j + 1]) {
   
            int temp = arr[j];
            arr[j] = arr[j + 1];
            arr[j + 1] = temp;
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

改进版冒泡排序：

​ 在冒泡排序中，各元素不断解决自己的位置，如果一趟比较下来，没有元素进行位置互换，则说明有序。利用flag判断元素是否进行过交换，flag=false 说明交换过。

/**
 * 冒泡排序，时间复杂度最高O(n²)，最佳时间复杂度是O(n)
 */
int[] arr = {
   12, 56, 3, 78, 39};
boolean flag=false;
for (int i = 0; i < arr.length-1; i++) {
   
    for (int j = 0; j < arr.length - 1 - i; j++) {
   
        if (arr[j] > arr[j + 1]) {
   
            flag=true;
            int temp = arr[j];
            arr[j] = arr[j + 1];
            arr[j + 1] = temp;
        }
    }
    if(!flag){
   
        break;
    }else {
   
        flag=false;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

复杂度分析：

以下是冒泡排序算法复杂度:

冒泡排序是最容易实现的排序, 最坏的情况是每次都需要交换, 共需遍历并交换将近n²/2次, 时间复杂度为O(n²). 最佳的情况是内循环遍历一次后发现排序是对的, 因此退出循环, 时间复杂度为O(n). 平均来讲, 时间复杂度为O(n²). 由于冒泡排序中只有缓存的temp变量需要内存空间, 因此空间复杂度为常量O(1).

2.选择排序

基本思想：

选择排序的思路很简单，它的基本思路是：首先在序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

选择排序的主要优点与数据移动有关。如果某个元素位于正确的最终位置上，则它不会被移动。选择排序每次交换一对元素，它们当中至少有一个将被移到其最终位置上，因此对 n个元素的表进行排序总共进行至多 n-1 次交换。在所有的完全依靠交换去移动元素的排序方法中，选择排序属于非常好的一种。

算法描述：

1. 从序列中找到关键字最小的元素
2. 如果最小元素不是序列的第一个元素，将其和序列第一个元素互换
3. 重复1、2步，直到排序结束。

代码实现：

    /*
    分为两步：第一步找最小
    		第二步交换位置
    */

public static void selection_sort(int[] a) {
   
        for(int i=0; i < a.length; i++){
   
            //从第i个元素开始找最小值，先设置最小值为第i个元素值，min代表的是位置而不是值。
            int min = i;
            //从第i+1到最后一个元素中依次比较第i个值是否为最小值
            for(int j = i + 1; j < a.length; j++){
   
                if(a[j] < a[min]){
   
                    min=j;
                }
            }
            //交换位置：最小值不等于当前值时进行交换
            if(min != i){
   
                int temp = a[i];
                a[i] = a[min];
                a[min] = temp;
            }
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

复杂度分析：

以下是选择排序复杂度:

总结与思考

选择排序的简单和直观名副其实，这也造就了它”出了名的慢性子”，无论是哪种情况，哪怕原数组已排序完成，它也将花费将近n²/2次遍历来确认一遍。即便是这样，它的排序结果也还是不稳定的。 唯一值得高兴的是，它并不耗费额外的内存空间。

3.插入排序

基本思想：

把n个待排序的元素看成一个有序表和一个无序表，开始时有序表只包含一个元素，无序表中包含有n-1个元素，排序过程中每次从无序表中取出一个元素，把它的排序码与有序表元素的排序码进行比较，将它插入到有序表的适当位置，成为