【Java 冒泡、选择，插入排序分析】简单理解

（假设我们的三种排序最终把数字从小到大排的）

一、冒泡排序

思想：对排序序列从前往后（从下标较小的元素开始），依次对相邻元素进行比较，若发现逆序就交换 使值较大的元素往后移动，此过程像水底下的泡泡往上冒。

代码实现：

public class TestBubble {
    public static void main(String[] args) {
        //测试下冒泡排序的速度（n^2）,我们用5000个数字来测试，直观的看看运行时间
        Integer[]arr = new Integer[5000];
        for (int i = 0;i<5000;i++){
            arr[i] = (int)(Math.random()*5000);//生成【0-5000）范围随机数字
        }
        long time1 = System.currentTimeMillis();
        BubbleSort(arr);
        long time2 = System.currentTimeMillis();
        long time3 = time2-time1;
        System.out.println("冒泡排序花费时间："+time3);//时间是有误差的，大概在180毫秒上下

    }
    //交换位置
    public static<T> void swap(T[]arr,int i,int j){
        T temp = arr[j];
        arr[j] = arr[i];
        arr[i] = temp;
    }
    //冒泡排序 时间复杂度（n^2）
    public static<T extends Comparable<T>> void BubbleSort(T [] arr){
        for (int i = 0;i<arr.length-1;i++){
            boolean flag = false;
            for (int j = 0;j<arr.length-1-i;j++){
                if (arr[j].compareTo(arr[j+1])>0){
                    flag = true;//如果交换了就true
                    swap(arr,j,j+1);
                }
            }
            if (!flag){//如果flag = true，说明没交换，直接返回就好
                return;
            }
        }
    }
}

二、选择排序

选择排序
思路：第一次从arr[0]~arr[n-1]中选取最小值，和arr[0]交换
第二次从arr[1]到~arr[n-1]中选取最小值，和arr[1]交换
以此类推，总共进行n-1次（因为最后一个元素不用排序了）

代码实现：

public class TestSelect {
    public static void main(String[] args) {
        //测试下选择排序的速度（n^2）,我们用5000个数字来测试，直观的看看运行时间
        Integer[]arr = new Integer[5000];
        for (int i = 0;i<5000;i++){
            arr[i] = (int)(Math.random()*5000);//生成【0-5000）范围随机数字
        }
        long time1 = System.currentTimeMillis();
        selectSort(arr);
        long time2 = System.currentTimeMillis();
        long time3 = time2-time1;
        System.out.println("选择排序花费时间："+time3);//误差在80毫秒上下，优与冒泡排序
    }
    public static <T extends Comparable<T>>void selectSort(T[]arr){
        for (int i = 0; i < arr.length - 1; i++) {
            int minIndex = i;
            T min = arr[i];//假定min是最小值
            for (int j = i + 1; j < arr.length; j++) {
                if (min.compareTo(arr[j]) > 0) {//说明arr[j]比假定的min小
                    min = arr[j];
                    minIndex = j;
                }
            }
            //最小值交换
            if (minIndex != i) {
                arr[minIndex] = arr[i];
                arr[i] = min;
            }
        }
    }
}

三、插入排序

思路：把n个待排序的元素看成一个一个有序表和一个无序表；开始时无序表只包含一个元素，有序表包含n-1 个元素，排序过程中，每次从无序表中拿出一个元素和有序表元素比较，插入合适位置，使之成为新的有序表

代码实现：

public class TestInster {
    public static void main(String[] args) {
        //测试下选择排序的速度（n^2）,我们用5000个数字来测试，直观的看看运行时间
        Integer[]arr = new Integer[5000];
        for (int i = 0;i<5000;i++){
            arr[i] = (int)(Math.random()*5000);//生成【0-5000）范围随机数字
        }
        long time1 = System.currentTimeMillis();
        insterSort(arr);
        long time2 = System.currentTimeMillis();
        long time3 = time2-time1;
        System.out.println("选择排序花费时间："+time3);
    }
    public static<T extends Comparable<T>> void insterSort(T[]arr){
        //定义待插入数
        for (int i = 1;i<arr.length;i++){
            T insterVal = arr[i];
            int insterIndex = i-1;//arr[1]这个元素前一个元素的下标
            while (insterIndex >= 0 && insterVal.compareTo(arr[insterIndex]) < 0) {
                //说明没找到插入位置，那就继续往前找 arr = {59，27 ，34}画图分析
                arr[insterIndex + 1] = arr[insterIndex];//把待插入数的前一个数，赋值到它在的位置
                insterIndex--;
            }
            //当退出while循环时，说明插入位置找到了：insterIndex+1这个位置
            arr[insterIndex + 1] = insterVal;
        }
    }
}

同样都是测试5000个随机数排序，在允许误差情况下，三种排序所用时间：
冒泡排序：180毫秒
选择排序：90毫秒
插入排序：40毫秒