JAVA算法 -- 冒泡排序及优化

冒泡排序法

算法思路：
1.比较相邻的元素并根据自己的设置交换；
2.对每一相邻元素作同样的操作，从开始到数组最后，这样在最后的元素应该会是最大/最小的数；
3.针对所有的元素重复以上的步骤，除了最后一个；
4.重复步骤1~3，直到排序完成。

时间复杂度：
1.最好的情况
   排序的数组本身有序，比较次数为n-1，没有数据的交换，此时复杂度为O(n)
2.最坏的情况
   数组为逆序的情况，此时需要的是O(n²)计算公式为：

（图片引用自文章https://blog.csdn.net/weixin_41835916/article/details/81661314）

基础实现版本代码：

/**
 * 冒泡排序 基础版
 *
 * @param arr
 */
public static void bubbleSortNormal(int[] arr) {
    if (null == arr || arr.length == 0) return;
    int len = arr.length;
    int tmp = 0;
    for (int i = 0; i < len; i++) {//外层循环控制次数 总趟数为arr.length
        for (int j = 0; j < len - i; j++) {//内层循环i次 所需比较次数
            if (arr[j] > arr[j + 1]) {
                tmp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = tmp ;
            }
        }
    }
}

优化版本代码1：

/**
 * 利用布尔变量isSorted作为标记。如果在本轮排序中，元素有交换，
 * 则说明数列无序；如果没有元素交换，说明数列已然有序，直接跳出大循环。
 * @param arr
 */
public static void bubbleSortOptOne(int arr[]) {
    int tmp = 0;//定义临时变量
    for (int i = 0; i < arr.length; i++) {
        //有序标记，每一轮的初始是true
        boolean isSorted = true;
        for (int j = 0; j < arr.length - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                tmp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = tmp;
                //此时有元素交换，非有序，标记false
                isSorted = false;
            }
        }
        if (isSorted) {
            break;
        }
    }
}

优化版本代码2：

/**
 * 优化2 sortBorder就是无序数列的边界。每一轮排序过程中，
 *      sortBorder之后的元素就完全不需要比较了，肯定是有序的
 * @param arr
 */
public static void bubbleSortOptOne(int arr[]) {
    int tmp = 0;
    //记录最后一次交换的位置
    int lastExchangeIndex = 0;
    //无序数列的边界，每次比较只需要比到这里为止
    int sortBorder = arr.length - 1;
    for (int i = 0; i < arr.length; i++) {
        //有序标记，每一轮的初始是true
        boolean isSorted = true;
        for (int j = 0; j < sortBorder; j++) {
            if (arr[j] > arr[j + 1]) {
                tmp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = tmp;
                //有元素交换，所以不是有序，标记变为false
                isSorted = false;
                //把无序数列的边界更新为最后一次交换元素的位置
                lastExchangeIndex = j;
            }
            sortBorder = lastExchangeIndex;
            if(isSorted){
                break;
            }
        }
    }
}

冒泡排序感想：

刚开始学习的时候仅会基础版本，在面试时发现小小的冒泡排序优化点也存在大学问，特整理出这篇文章，和大家一起相互学习，如有问题，也希望大家指正

文章引用如下

冒泡排序算法优化：https://blog.csdn.net/wubingju93123/article/details/81215984

排序算法--冒泡排序（1）：https://zhuanlan.zhihu.com/p/61094267

Java面试--排序算法：https://blog.csdn.net/weixin_41835916/article/details/81661314