常见的4种排序方式------冒泡，选择，插入，快速_随机函数产生10000个随机数,用快速排序,直接插入排序,冒泡排序,选择排序的排序方

一.冒泡排序

1.冒泡排序是一种简单的排序算法，它重复地比较相邻的元素，如果顺序错误就交换它们的位置，直到没有相邻元素需要交换，也就是说该元素列已经排序完成.冒泡排序的原理是从左到右，相邻元素进行比较，每次比较一轮，就会找到序列中最大的一个或最小的一个，这个数就会从序列的最右边冒出来，一轮一轮地比较，最后实现排序.冒泡排序的时间复杂度为O(n²)，是一种稳定排序算法，可以使用多种编程语言实现.

1.1 算法步骤
相邻的元素两两比较，大的放右边，小的放左边
第一轮比较完毕之后，最大值就已经确定，第二轮可以少循环一次，后面以此类推
如果数组中有n个数据，总共我们只要执行n-1轮的代码就可以

1.2动图演示

1.3代码示例

import java.util.Random;

public class SortDemo {
    public static void main(String[] args) {
        //生成一个无序数组
        int []arr = new int[100000];
        Random r = new Random();
        for(int i = 0;i < arr.length;i ++){
            arr[i] = r.nextInt();
        }
        //排序前的数组
       // Print(arr);
        //记录排序前的时间
        long time1 = System.currentTimeMillis();
        //冒泡排序,减一是因为最后一轮不需要比较
        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;

                }
            }
        }
        //记录排序后的时间
        long time2 = System.currentTimeMillis();
        //排序所所需的时间
         System.out.println("冒泡排序 100000个数所用时间为：");
        System.out.println(time2 - time1 + "毫秒");
        //排序后的数组
       // Print(arr);

    }

     // 用于打印数组

    public static void Print(int [] arr){
        for(int i = 0;i < arr.length;i ++)
        {
            System.out.print(arr[i]+" ");
        }
        System.out.println();
    }
}

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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

二.选择排序

2.选择排序是一种简单直观的排序算法。它的工作原理是：第一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后再从剩余的未排序元素中寻找到最小（大）元素，然后放到已排序的序列的末尾。以此类推，直到全部待排序的数据元素的个数为零。选择排序是不稳定的排序方法。

2.1 算法步骤
从0索引开始，跟后面的元素一一比较
小的放前面，大的放后面
第一次循环结束后，最小的数据已经确定
第二次循环从1索引开始以此类推
第三轮循环从2索引开始以此类推
第四轮循环从3索引开始以此类推。

2.2 动图演示

2.3代码示例

public class SortDemo2 {
    public static void main(String[] args) {
        int arr [] = {2,4,1,9,3,7,6,8,10,0,5};
        //选择排序
        for(int i = 0;i < arr.length;i ++){
            for(int j = i + 1;j < arr.length;j ++){
                if(arr[i] > arr[j] ){
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }
        Print(arr);
    }
    public static void Print(int [] arr){
        for(int i = 0;i < arr.length;i ++)
        {
            System.out.print(arr[i]+" ");
        }
        System.out.println();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

三.插入排序

3.插入排序的代码实现虽然没有冒泡排序和选择排序那么简单粗暴，但它的原理应该是最容易理解的了，因为只要打过扑克牌的人都应该能够秒懂。插入排序是一种最简单直观的排序算法，它的工作原理是通过创建有序序列和无序序列，然后再遍历无序序列得到里面每一个数字，把每一个数字插入到有序序列中正确的位置。
插入排序在插入的时候，有优化算法，在遍历有序序列找正确位置时，可以采取二分查找

3.1 算法步骤
将0索引的元素到N索引的元素看做是有序的，把N+1索引的元素到最后一个当成是无序的。
遍历无序的数据，将遍历到的元素插入有序序列中适当的位置，如遇到相同数据，插在后面。
N的范围：0~最大索引

3.2 动图演示

3.3代码演示

public class SortDemo3 {
    public static void main(String[] args) {
        int arr [] = {2,4,1,9,3,7,6,8,10,0,5};
        //插入排序
        //找无序排列的第一位数的下标
        int start = -1;
        for(int i = 0;i < arr.length-1;i ++){
            if(arr[i] > arr[i+1]){
                start = i+1;
                break;
            }
        }

        //将无序排列的数插入到有序排列当中
        for(int j = start;j < arr.length;j ++)
            while (j>0&&arr[j]<arr[j-1]){
                int temp = arr[j-1];
                arr[j-1] = arr[j];
                arr[j] = temp;
                j--;
            }
        Print(arr);

    }
    public static void Print(int [] arr){
        for(int i = 0;i < arr.length;i ++)
        {
            System.out.print(arr[i]+" ");
        }
        System.out.println();
    }
}

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
29
30
31
32
33

四.快速排序

4.快速排序是由东尼·霍尔所发展的一种排序算法。

快速排序又是一种分而治之思想在排序算法上的典型应用。

快速排序的名字起的是简单粗暴，因为一听到这个名字你就知道它存在的意义，就是快，而且效率高！

它是处理大数据最快的排序算法之一了。

4.1 算法步骤

从数列中挑出一个元素，一般都是左边第一个数字，称为 “基准数”;

创建两个指针，一个从前往后走，一个从后往前走。

先执行后面的指针，找出第一个比基准数小的数字

再执行前面的指针，找出第一个比基准数大的数字

交换两个指针指向的数字

直到两个指针相遇

将基准数跟指针指向位置的数字交换位置，称之为：基准数归位。

第一轮结束之后，基准数左边的数字都是比基准数小的，基准数右边的数字都是比基准数大的。

把基准数左边看做一个序列，把基准数右边看做一个序列，按照刚刚的规则递归排序

4.2 动图演示

4.3代码演示

import java.util.Random;

public class SortDemo1 {
    public static void main(String[] args) {
        //生成一个无序数组
        int []arr = new int[100000];
        Random r = new Random();
        for(int i = 0;i < arr.length;i ++){
            arr[i] = r.nextInt();
        }
        //排序前的数组
        // Print(arr);
        //记录排序前的时间
        long time1 = System.currentTimeMillis();
        //快速排序
        quicksort(arr, 0, arr.length-1);


        long time2 = System.currentTimeMillis();
        //排序所所需的时间
        System.out.println("快速排序 100000个数所用时间为：");
        System.out.println(time2 - time1 + "毫秒");
        //排序后的数组
         //Print(arr);
    }
    public static void quicksort(int []arr, int i, int j){
        int start = i;
        int end = j;
        //递归的出口
        if(end < start){
            return;
        }
        //定义第一个数为基准数
        int baseNumber = arr[i];

        while (start != end){
            while (true){
                //从后往前找比基准数小的数
                if(baseNumber > arr[end] || end <= start){
                    break;
                }
                end --;
            }
            while (true){
                //从前往后找比基准数大的数
                if(baseNumber < arr[start] || end <= start){
                    break;
                }
                start ++;
            }
            //交换end和start索引的数据
            int temp = arr[start];
            arr[start] = arr[end];
            arr[end] = temp;
        }
        //基准数归位
        int temp = arr[i];
        arr[i] = arr[start];
        arr[start] = temp;
        //基准数左边的数重新调用该方法
        quicksort(arr, i, start - 1);
        //基准数右边的数重新调用该方法
        quicksort(arr,start + 1, j);

    }
    public static void Print(int [] arr){
        for(int i = 0;i < arr.length;i ++)
        {
            System.out.print(arr[i]+" ");
        }
        System.out.println();
    }
}

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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

4.4比较其他三种排序，排相同的数据，快速排序所用时间最短。
下面以冒泡排序与快速排序排100000个数所用的时间为例

冒泡排序所用的时间为：

快速排序所用的时间为：

对比两张图片，明显看出快速排序比冒泡排序节省了很多时间。

五.小结

在学完这几种排序后感觉有些地方还是不够熟练，因此想借此机会再把这几种排序巩固一下，顺便写一下自己的思路和表达一下自己的想法。希望我的这些感悟能够帮助到各位，谢谢各位的观看。
码字不易，大家的支持就是我坚持的动力。记得点赞哦！