关于冒泡排序和快排比较

版权声明：可供大家一起学习，禁止抄袭！！！ https://blog.csdn.net/qq_38036909/article/details/90479484

冒泡排序

    //  冒泡排序
    private static String bubbling() {
        int[] arr = arr();
        int index;
        long startTime = System.nanoTime();
        long startTime1 = System.currentTimeMillis();
        for (int j = arr.length; j > 0; j--) {
            for (int i = 0; i < j; i++) {
                if (i < arr.length - 1) {
                    if (arr[i] > arr[i + 1]) {
                        index = arr[i + 1];
                        arr[i + 1] = arr[i];
                        arr[i] = index;
                        time += 1;
                    }
                }
            }
        }
        return Arrays.toString(arr);
    }

快排

    //快排
    private static void sort(int[] arr, int left, int right) throws Exception {
        if(left>=right){
            return ;
        }
        int index= 0;
        index = partition(arr,left,right);
        sort(arr,left,index-1);
        sort(arr,index+1,right);
    }
    
    private static int partition(int[] arr, int left, int right) throws Exception {
        //固定的切分方式
        int key=arr[left];
        while(left<right){
            while(arr[right]>=key&&right>left){//从后半部分向前扫描
                right--;
            }
            arr[left]=arr[right];
            while(arr[left]<=key&&right>left){//从前半部分向后扫描
                left++;
            }
            arr[right]=arr[left];
        }
        arr[right]=key;
        return right;
    }

自定义排序(直排)

    //自定义排序
    private static void le(int[] arr, int left, int right) throws Exception {
        if (right == 0){
            return;
        }
        int t;
        while (left < right) {
            while (arr[left] <= arr[right] && left < right) {
                left++;
            }
            if (arr[left] > arr[right] && left < right) {
                t = arr[left];
                arr[left] = arr[right];
                arr[right] = t;
            }
            left++;
        }
        if (left >= right) {
            le(arr, 0, --right);
        }

    }

总结

在相同条件下对这三种排序进行了测试，在随机数在10以内的数组测试结果如下：

• 冒泡排序所用时间： 14578 ns
• 快排所用时间：17278 ns
• 自定义排序所用时间：10259 ns
  在相同条件下对这三种排序进行了测试，在随机数在3000以内的数组测试结果如下：
• 冒泡排序所用时间： 64 ms
• 快排所用时间：27 ms
• 自定义排序所用时间：25 ms
  在相同条件下对这三种排序进行了测试，在随机数在10000以内的数组测试结果如下：
• 冒泡排序所用时间： 404 ms
• 快排所用时间：55 ms
• 自定义排序所用时间：88 ms

测试结果在相同条件下随机数在10左右所用时间：自定义排序 < 冒泡排序 < 快排
测试结果在相同条件下随机数在3000左右所用时间：自定义排序 < 快排 < 冒泡排序
测试结果在相同条件下随机数超过3000所用时间：快排 < 自定义排序 < 冒泡排序
或许自定义排序可能只是快排的一种写法，有知道的请在下方评论。