经典算法分析：n^2与nlgn

冒泡、插入、选择排序的时间复杂度为O（n²）

Arrays.sort()时间复杂度为nlgn

具体算法实现代码：

package recursion;

import java.util.Arrays;

/**
 * @author zsh
 * @company wlgzs
 * @create 2019-02-17 9:46
 * @Describe 冒泡、插入、选择排序与Arrays.sort()的性能差别
 */
public class Main3 {

    /**
     * 冒泡排序
     * @param arr 待排序的数组
     * @return 已排序的数组
     */
    static int[] bubbleSort(int[] arr){
        //外层循环执行N-1趟
        for (int i = 0; i < arr.length -1; i++) {
            //内层循环执行N-1-i趟
            for (int j = 0; j < arr.length -1 -i ; j++) {
                //如果数组前一个元素比后一个元素的值大，交换
                if (arr[j] > arr[j+1]){
                    int temp = arr[j+1];
                    arr[j+1] = arr[j];
                    arr[j] = temp;
                }
            }
        }
        return arr;
    }

    /**
     * insertSort(arr,k) 递归实现插入排序
     * 找重复：insertSort(arr,k-1) 将k-1个排序后，把arr[k]插入到前面的数据中 --子问题
     * 找变化：变化的量应该作为参数 k。
     * 找边界：出口 终止的条件 k == 0
     */
    static int[] insertSort(int[] arr,int k){
        if (k == 0){
            return arr;
        }
        //对前k-1个元素排序
        insertSort(arr,k-1);
        //把k位置上的元素插入到前面的部分
        int x = arr[k];
        int index = k -1;
        while (index >= 0 && x <arr[index]){
            arr[index+1] = arr[index];
            index--;
        }
        arr[index+1] = x;
        return arr;
    }


    /**
     * 选择排序
     * @param arr 待排序的数组
     * @return 已排序的数组
     */
    static int[] selectionSort(int[] arr){
        for (int i = 0; i < arr.length-1; i++) {
            int k = i;
            for (int j = i + 1; j < arr.length ; j++) {
                if (arr[j] < arr[k]){
                    //记录此时找到最小值的位置
                    k = j;
                }
            }
            //内层循环结束，找到最小值后进行交换
            if (i != k){
                int temp = arr[i];
                arr[i] = arr[k];
                arr[k] = temp;
            }
        }
        return arr;
    }

    public static void main(String[] args) {
        //构造随机数组
        int[] arr = new int[10000];
        for (int i = 0; i < arr.length; i++) {
            double a = Math.random()*10000;
            arr[i] = (int) a;
        }
        //调用冒泡排序进行
        long time1 = System.currentTimeMillis();
        System.out.println(Arrays.toString(bubbleSort(arr)));
        long time2 = System.currentTimeMillis();
        System.out.println(time2-time1+"ms");
        //调用插入排序进行(使用递归)
        long time3 = System.currentTimeMillis();
        System.out.println(Arrays.toString(insertSort(arr,arr.length-1)));
        long time4 = System.currentTimeMillis();
        System.out.println(time4-time3+"ms");
        //调用选择排序进行
        long time5 = System.currentTimeMillis();
        System.out.println(Arrays.toString(selectionSort(arr)));
        long time6 = System.currentTimeMillis();
        System.out.println(time6-time5+"ms");
        //调用Arrays.sort()进行
        long time7 = System.currentTimeMillis();
        Arrays.sort(arr);
        long time8 = System.currentTimeMillis();
        System.out.println(Arrays.toString(arr));
        System.out.println(time8-time7+"ms");
    }

}

控制台输出：