快速排序 归并排序 Collections.sort正序倒序乱序性能分析

一、快速排序：

1:快速排序性能测试，随机数10000个打乱排序乱序、正序、倒序写法如下

public class QuickSort {

    //第一步
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        for(int i=0;i<10000;i++) {
            list.add(new Random().nextInt(90000));
        }
        Object[] objects = list.toArray();
        int[] arr = new int[objects.length];
        for(int i = 0; i<objects.length;i++) {
            arr[i] = (Integer) objects[i];
        }
        long time1=System.currentTimeMillis();

        quickSort(arr, 0, arr.length-1);

        long time2=System.currentTimeMillis();
        Long unSort1000000 = time2 - time1;//乱序用时毫秒
        System.out.println("乱序用时："+unSort1000000+" ms");
        //开始正序排序
        quickSort(arr, 0, arr.length-1);
        long time3=System.currentTimeMillis();
        Long sort1000000 = time3 - time2;//正序用时秒
        System.out.println("正序用时："+sort1000000+" ms");
        Collections.sort(list, Collections.reverseOrder());
        Object[] object1 = list.toArray();
        int[] arr1 = new int[object1.length];
        for(int i = 0; i<object1.length;i++) {
            arr1[i] = (Integer) object1[i];
        }

        long reverse1 = System.currentTimeMillis();
        quickSort(arr1, 0, arr.length-1);//倒序排序
        long reverse2 = System.currentTimeMillis();
        long reverseSort = reverse2 - reverse1;
        System.out.println("倒序排列：" +reverseSort +" ms");

    }

    public static void quickSort(int[] arr,int start ,int end) {
        if(start<end) {//有元素再排序
            //选择数组中的第零个数字做为标准数
            int base = arr[start];
            //记录需要排序第下标
            int low = start;//开始位置
            int high = end;//结束位置
            //需要循环去找数字比标准数大的，和小的数替换
            while (low < high) {
                //右边比标准数大
                while (low < high && base <= arr[high]) {
                    high--;//内移动下标，数字不需要替换
                }
                //使用右边数字替换左边数字
                arr[low] = arr[high];
                //如果左边数字比标准小
                while (low < high && arr[low] <= base) {
                    low++;//
                }
                //指向同一位置
                arr[high] = arr[low];
            }
            //把标准数给低或者高的元素
            arr[low] = base;
            //处理所有比标准数小的
            quickSort(arr, start, low);
            //处理所有比标准数大的
            quickSort(arr, low + 1, end);

        }
    }
}

2:运行效果如下所示：

 

二、归并排序：

1:归并排序性能测试，随机数10000个打乱排序乱序、正序、倒序写法如下

public class MergerSort {

    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        for(int i=0;i<10000;i++) {
            list.add(new Random().nextInt(1000000));
        }
        Object[] objects = list.toArray();
        int[] arr = new int[objects.length];
        for(int i = 0; i<objects.length;i++) {
            arr[i] = (Integer) objects[i];
        }
        long time1=System.currentTimeMillis();

        mergeSort(arr, 0, arr.length-1);

        long time2=System.currentTimeMillis();

        Long unSort1000000 = time2 - time1;
        System.out.println("乱序排序" + unSort1000000 + "ms");
        mergeSort(arr, 0, arr.length-1);
        long time3 = System.currentTimeMillis();
        Long sort1000000 = time3 - time2;
        System.out.println("正序排序" + sort1000000 + "ms");

        Collections.sort(list, Collections.reverseOrder());
        Object[] object1 = list.toArray();
        int[] arr1 = new int[object1.length];
        for(int i = 0; i<object1.length;i++) {
            arr1[i] = (Integer) object1[i];
        }

        long reverse1 = System.currentTimeMillis();
        mergeSort(arr1, 0, arr.length-1);
        long reverse2 = System.currentTimeMillis();
        long reverseSort = reverse2 - reverse1;
        System.out.println("倒序排列：" +reverseSort +" ms");
    }

    public static void merge(int[] arr, int low, int mid, int high) {
        int[] temp = new int[high-low +1];
        int i = low;
        int j = mid+1;
        int index = 0;

        while (i<=mid&&j<=high) {
            if(arr[i] <=arr[j]) {
                temp[index] = arr[i];
                i++;
                index++;
            }else {
                temp[index] = arr[j];
                j++;
                index++;
            }
        }
        while (i<=mid) {
            temp[index] = arr[i];
            i++;
            index++;
        }
        while (j<=high) {
            temp[index] = arr[j];
            j++;
            index++;
        }

        for(int k= 0;k<temp.length;k++) {
            arr[low+k] = temp[k];
        }

    }

    public static void mergeSort(int[] arr, int low ,int high) {
        if(low<high) {
//            int mid = (high-low) << 1 + low;
            int mid = (high+low)/2;
            mergeSort(arr,low,mid);
            mergeSort(arr,mid+1, high);
            merge(arr,low,mid,high);
        }
    }
}

2:运行效果如下所示：

三、Collections.sort排序：

1:Collections.sort排序性能测试，随机数10000个打乱排序乱序、正序、倒序写法如下

public class CollectionSort {

    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        for(int i=0;i<10000;i++) {
            list.add(new Random().nextInt(90000));
        }
        Object[] objects = list.toArray();
        int[] arr = new int[objects.length];
        for(int i = 0; i<objects.length;i++) {
            arr[i] = (Integer) objects[i];
        }
        long time1 = System.currentTimeMillis();
        Collections.sort(list);
        long time2=System.currentTimeMillis();
        Long unSort1000000 = time2 - time1;//乱序用时毫秒
        System.out.println("乱序用时："+unSort1000000+" ms");

        Collections.sort(list);

        long time3=System.currentTimeMillis();
        Long sort1000000 = time3 - time2;//正序用时秒
        System.out.println("正序用时："+sort1000000+" ms");

        Collections.sort(list, Collections.reverseOrder());
        Object[] object1 = list.toArray();
        int[] arr1 = new int[object1.length];
        for(int i = 0; i<object1.length;i++) {
            arr1[i] = (Integer) object1[i];
        }

        long reverse1 = System.currentTimeMillis();
        Collections.sort(list);
        long reverse2 = System.currentTimeMillis();
        long reverseSort = reverse2 - reverse1;
        System.out.println("倒序排列：" +reverseSort +" ms");
    }
}

2:运行效果如下所示：

 

四、速度对比：经过多次运行，结果比例均大至稳定（本文只截取某一次结果进行讲解）

	乱序	正序	倒序
快速排序	2ms	29ms	24ms
归并排序	7ms	5ms	1ms
CollectionSort	14ms	1ms	1ms

 

 

 

 

 

五、实验过程中遇到的问题，快速排序一定是最快的么？不一定，乱序时候比较快，其他时候就比较慢了，而且快排极不稳定，在递归调用太深的情况下它会报溢出的错误。感兴趣可以把10000变大一些。Collections.sort中采用的核心算法是TimSort.sort

它是增强型的归并排序法，性能对比归并要强大一些。保证此排序是稳定的（不会因调用 sort 方法而对相等的元素进行重新排序。这一点快排就满足不了。）