冒泡排序以及冒泡排序的升级版

最新推荐文章于 2022-05-18 16:41:40 发布

zhaobo156

最新推荐文章于 2022-05-18 16:41:40 发布

阅读量439

点赞数

分类专栏：算法类

本文链接：https://blog.csdn.net/zhaobo156/article/details/108527738

版权

算法类专栏收录该内容

3 篇文章 0 订阅

订阅专栏

这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端（升序或降序排列），就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样，故名“冒泡排序”。
它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果顺序（如从大到小、首字母从Z到A）错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素列已经排序完成。

冒泡排序算法的原理如下：

比较相邻的元素。如果第一个比第二个大，就交换他们两个。
对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
针对所有的元素重复以上的步骤，除了最后一个。
持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

场景1：int[] arr = {5,9,6,3,10,2,0,8};
由原理可写出最常见的冒泡排序代码1：

public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = {5,9,6,3,10,2,0,8};
        bubbleSort1(arr);
        System.out.println(JSON.toJSON(arr));
    }

    private static void bubbleSort1(int[] arr) {
        if(arr == null || arr.length < 2 ){
            return;
        }
        int temp = 0;
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr.length - i -1; j++) { 
                if (arr[j] > arr[j + 1]) {
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
            System.out.println("第"+ (i+1) +"轮:" +JSON.toJSON(arr));
        }
    }
}

输出结果：

第1轮:[5,6,3,9,2,0,8,10]
第2轮:[5,3,6,2,0,8,9,10]
第3轮:[3,5,2,0,6,8,9,10]
第4轮:[3,2,0,5,6,8,9,10]
第5轮:[2,0,3,5,6,8,9,10]
第6轮:[0,2,3,5,6,8,9,10]
第7轮:[0,2,3,5,6,8,9,10]
第8轮:[0,2,3,5,6,8,9,10]

代码1结论：

由输出的结果可知，在进行第七轮排序的时候，便检查到数组已经是一个有序数组了，可以省略第八轮的排序。

所以便有了以下优化代码2：

private static void bubbleSort2(int[] arr) {
        if(arr == null || arr.length < 2 ){
            return;
        }
        int temp = 0;
        for (int i = 0; i < arr.length; i++) {
            boolean isSorted = true;
            for (int j = 0; j < arr.length - i -1; j++) {  
                if (arr[j] > arr[j + 1]) {
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                    isSorted = false;
                }
            }
            System.out.println("第"+ (i+1) +"轮:" +JSON.toJSON(arr));
            if(isSorted) break;
        }
    }

输出结果：

第1轮:[5,6,3,9,2,0,8,10]
第2轮:[5,3,6,2,0,8,9,10]
第3轮:[3,5,2,0,6,8,9,10]
第4轮:[3,2,0,5,6,8,9,10]
第5轮:[2,0,3,5,6,8,9,10]
第6轮:[0,2,3,5,6,8,9,10]
第7轮:[0,2,3,5,6,8,9,10]

代码2结论：

在排序过程中，加一个数组是否有序的标识，默认数组为一个有序数组；
如果有元素交换，说明数组还在调整，有序标识设为false;
如果一轮下来都没有元素交换，说明数组已经是一个有序数组了，可跳出循环。

场景2：int[] arr2 = {5,0,6,3,7,8,9,10}; 数组后半部分有序，如果用优化过后的代码2排序，执行结果如下：

第1轮:[5,3,0,6,7,8,9,10]
第2轮:[3,0,5,6,7,8,9,10]
第3轮:[0,3,5,6,7,8,9,10]
第4轮:[0,3,5,6,7,8,9,10]

结论：

排序轮数有减少，但是细想在每一轮中的对比过程，后四个元素是不用参与对比的；
同样可加一个标识，标记出数组从第几个元素开始是有序的，下一轮排序后几位元素可不参与

优化代码3：

private static void bubbleSort3(int[] arr) {
        if(arr == null || arr.length < 2 ){
            return;
        }
        int temp = 0;
        int flag = arr.length-1;
        int x = 0;
        for (int i = 0; i < arr.length; i++) {
            boolean isSorted = true;
            for (int j = 0; j < flag; j++) {
                if (arr[j] > arr[j + 1]) {
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                    isSorted = false;
                    //记录最后一个交换元素的位置
                    x = j;
                }
                System.out.println("第"+ (i+1) +"轮-" +"第"+ (j+1) +"次:" +JSON.toJSON(arr));
            }
            flag = x;
            System.out.println("第"+ (i+1) +"轮结束:" +JSON.toJSON(arr));
            if(isSorted) break;
        }
    }

输出结果：

第1轮-第1次:[5,6,3,0,7,8,9,10]
第1轮-第2次:[5,3,6,0,7,8,9,10]
第1轮-第3次:[5,3,0,6,7,8,9,10]
第1轮-第4次:[5,3,0,6,7,8,9,10]
第1轮-第5次:[5,3,0,6,7,8,9,10]
第1轮-第6次:[5,3,0,6,7,8,9,10]
第1轮-第7次:[5,3,0,6,7,8,9,10]
第1轮结束:[5,3,0,6,7,8,9,10]
第2轮-第1次:[3,5,0,6,7,8,9,10]
第2轮-第2次:[3,0,5,6,7,8,9,10]
第2轮结束:[3,0,5,6,7,8,9,10]
第3轮-第1次:[0,3,5,6,7,8,9,10]
第3轮结束:[0,3,5,6,7,8,9,10]
第4轮结束:[0,3,5,6,7,8,9,10]

结论：

每经过上一轮的排序后，就记录一下flag,下一轮排序对比至这个标识处即可。

场景3：int[] arr3 = {3,4,5,6,7,8,9,1}; 前半部分有序，可是使用冒泡排序（将最大的元素移到数组最后）的时候依然要执行完8轮的对比；
优化思想：

第一轮排序过后，结果如下：[3,4,5,6,7,8,1,9]；
这时发现，只有元素1影响了整个数组的顺序；
这时可对数组{3,4,5,6,7,8,1} 反过来进行最小元素移到最前端的排序；
一轮大数往后移，一轮小数往前移比较适合这种前半部分有序的数组

优化代码4（鸡尾酒排序）：

private static void bubbleSort4(int[] arr) {
        if(arr == null || arr.length < 2 ){
            return;
        }
        int temp = 0;
        for (int i = 0; i < arr.length/2; i++) {
            boolean isSorted = true;
            for (int j = 0; j < arr.length - i -1; j++) {
                if (arr[j] > arr[j + 1]) {
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                    isSorted = false;
                }
            }
            System.out.println("第"+ (i+1) +"轮正排序:" +JSON.toJSON(arr));
            if(isSorted) break;

            isSorted = true;
            for (int j = arr.length - i -1; j>i; j--) {
                if (arr[j] < arr[j - 1]) {
                    temp = arr[j];
                    arr[j] = arr[j - 1];
                    arr[j - 1] = temp;
                    isSorted = false;
                }
            }
            System.out.println("第"+ (i+1) +"轮倒排序:" +JSON.toJSON(arr));
            if(isSorted) break;
        }
    }

输出结果：

第1轮正排序:[3,4,5,6,7,8,1,9]
第1轮倒排序:[1,3,4,5,6,7,8,9]
第2轮正排序:[1,3,4,5,6,7,8,9]

最后，再结合之前代码3的优化思想可得出代码5：

private static void bubbleSort5(int[] arr) {
        if(arr == null || arr.length < 2 ){
            return;
        }
        int temp = 0;
        int rightFlag = arr.length-1;
        int leftFlag = 0;
        int lx = 0;
        int rx = 0;
        for (int i = 0; i < arr.length/2; i++) {
            int x= 1;
            boolean isSorted = true;
            for (int j = leftFlag; j < rightFlag; j++) {
                if (arr[j] > arr[j + 1]) {
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                    isSorted = false;
                    rx = j;
                }
                System.out.println("第"+ (i+1) +"轮正排序-" +"第"+ (x++) +"次:" +JSON.toJSON(arr));
            }
            rightFlag = rx;
            System.out.println("第"+ (i+1) +"轮正排序:" +JSON.toJSON(arr));
            if(isSorted) break;

            int y = 1;
            isSorted = true;
            for (int j = rightFlag; j > leftFlag; j--) {
                if (arr[j] < arr[j - 1]) {
                    temp = arr[j];
                    arr[j] = arr[j - 1];
                    arr[j - 1] = temp;
                    isSorted = false;
                    lx = j;
                }
                System.out.println("第"+ (i+1) +"轮倒排序-" +"第"+ (y++) +"次:" +JSON.toJSON(arr));
            }
            leftFlag = lx;
            System.out.println("第"+ (i+1) +"轮倒排序:" +JSON.toJSON(arr));
            if(isSorted) break;
        }
    }

鸡尾酒排序适合特定条件下（大部分元素已经有序）使用，但其代码量也扩大了一倍。

zhaobo156

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
冒泡排序以及冒泡排序的升级版

这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端（升序或降序排列），就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样，故名“冒泡排序”。它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果顺序（如从大到小、首字母从Z到A）错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素列已经排序完成。冒泡排序算法的原理如下：比较相邻的元素。如果第一个比第二个大，就交换他们两个。对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，
复制链接

扫一扫

专栏目录