数组冒泡排序，快速排序，原生排序方法的效率对比

数组排序有很多种方式，数据量小时效率差别不大，但数据量大的时候效率差别则十分明显，本文拿最常用的三种排序方法进行对比，即冒泡排序法，快速排序法，还有Arrays类提供的原生sort()方法。

方法一：冒泡排序1

 /**
     * 冒泡排序法，定义第三个临时变量实现两个数的交换----效率差
     * @param array
     */
    private static int[] sortMaoPao1(int[] array){
        long start = System.currentTimeMillis();
        //外层循环控制比较几轮
        for(int i = 0; i < array.length-1; i++){
            //内层循环控制每轮比较几个元素
            for(int j = 0; j < array.length-i-1; j++){
                //升序
                if(array[j] > array[j+1]){
                    //定义第三变量使两个变量互换位置
                    int temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                }
            }
        }
        long end = System.currentTimeMillis();
        long time = end - start;
        System.out.println("冒泡1耗时：" + time);
        return array;
    }

方法二：冒泡排序2

 /**
     * 冒泡排序，用位运算实现两个数之间的交换----效率跟定义第三个变量互换的方法差不多，其实就是写法不一样，当温故知新
     * @param array
     */
    private static int[] sortMaoPao2(int[] array){
        long start = System.currentTimeMillis();
        //外层循环控制比较几轮
        for(int i = 0; i < array.length -1; i++){
            //内层循环控制每轮比较几次
            for(int j = 0; j < array.length - i -1; j++){
                if(array[j] > array[j+1]){
                    //用位运算实现第两个数之间第交换
                    array[j] = array[j] ^ array[j+1];
                    array[j+1] = array[j] ^ array[j+1];
                    array[j] = array[j] ^ array[j+1];
                }
            }
        }
        long end = System.currentTimeMillis();
        long time = end - start;
        System.out.println("冒泡2耗时：" + time);
        return array;
    }

方法三：数组提供的原生排序方法

 /**
     * 使用数组原生的排序方法,效率高
     * @param array
     */
    private static int[] sort3(int[] array){
        long start = System.currentTimeMillis();
        Arrays.sort(array);
        System.out.println("数组原生排序耗时："+(System.currentTimeMillis()-start));
        return array;
    }

方法四：快速排序法

 /**
     * 快速排序法=冒泡+分治+递归
     * @param array 数组
     * @param low 数组首位元素指针
     * @param high 数组末尾元素指针
     */
    private static int[] quickSort(int[] array,int low, int high){
        long start = System.currentTimeMillis();
        if(low < high){
            sortKS(array,low,high);
        }
        System.out.println("数组快速排序耗时："+(System.currentTimeMillis()-start));
        return array;
    }

    /**
     * 快速排序=冒泡+分治+递归；经过一轮排序后，基准数左边全是小于基准数；右边全是大于基准数元素；
     * 然后分别把基准数两边的数组元素分别重复进行第一轮排序；
     * @param array 数组
     * @param low 数组首位元素指针
     * @param high 数组末尾元素指针
     */
    private static void sortKS(int[] array,int low, int high){
        if(low >= high){
            return ;
        }
        //指定两个指针，分别执行分区起始元素和结束元素
        int i = low;
        int j = high;
        //指定基数；可以是数组中任意一元素
        int base = array[low];
        while (i < j){
            //从右边末尾指针开始向左移动；找到第一个小于基准数的元素
            while (i < j && array[j] >= base){
                j--;
            }
            //把第一个小于基准数的元素赋值给第一个元素
            if(i < j){
                array[i++] = array[j];
            }
            //从左边第一个元素指针向右移动；找到第一个大于基准数的元素
            while(i < j && array[i] < base){
                i++;
            }
            //然后把这个小于基准数的元素赋值给上面小于基准数位置的元素；其实就是实现位置互换
            if(i < j){
                array[j--] = array[i];
            }
        }
        //当i==j时就是基准数的位置
        array[i] = base;
        //递归重复第一轮操作
        sortKS(array,low,i-1);
        sortKS(array,i+1,high);
    }

用4个长度30000的整型数组测试一下

 	public static void main(String[] args) {
        int[] array = generateArray(30000);
        int[] array2 = generateArray(30000);
        int[] array3 = generateArray(30000);
        int array4[] = generateArray(30000);
        System.out.println("冒泡排序1排序后；" + Arrays.toString(sortMaoPao1(array4)));
        System.out.println("冒泡排序2排序后；" + Arrays.toString(sortMaoPao2(array3)));
        System.out.println("原生数组方法排序后：" + Arrays.toString(sort3(array)));
        System.out.println("数组快速排序后：" + Arrays.toString(quickSort(array2,0,array2.length-1)));
    }
    /**
     * 生成length长度的int数组
     * @param length
     * @return
     */
    private static int[] generateArray(int length){
        int[] array = new int[length];
        Random random = new Random();
        for (int i = 0; i < length; i++){
            array[i] = random.nextInt(1000000);
        }
        return array;
    }

多册测试结果

结论：冒泡排序时间复杂度为O(N^2)，效率差；原生提供的sort()排序和快速排序效率相当，数据越大效率越明显