排序算法突击（Java）：冒泡排序

Posted 2022-05-10 流楚丶格念

文章目录

• 冒泡排序
• • 冒泡三种写法：
  • 冒泡第一种写法：
  • 冒泡排序的第二种写法
  • 冒泡排序的第三种写法
• 时间复杂度 & 空间复杂度分析
• 小技巧
• • 两数交换技巧

冒泡排序

冒泡三种写法：

冒泡排序是入门级的算法，但也有一些有趣的玩法。通常来说，冒泡排序有三种写法：

• 一边比较一边向后两两交换，将最大值 / 最小值冒泡到最后一位；
• 经过优化的写法：使用一个变量记录当前轮次的比较是否发生过交换，如果没有发生交换表示已经有序，不再继续排序；
• 进一步优化的写法：除了使用变量记录当前轮次是否发生交换外，再使用一个变量记录上次发生交换的位置，下一轮排序时到达上次交换的位置就停止比较。

冒泡第一种写法：

public static void bubbleSort(int[] arr) 
    for (int i = 0; i < arr.length - 1; i++) 
        for (int j = 0; j < arr.length - 1 - i; j++) 
            if (arr[j] > arr[j + 1]) 
                // 如果左边的数大于右边的数，则交换，保证右边的数字最大
                swap(arr, j, j + 1);
            
        
    

// 交换元素
private static void swap(int[] arr, int i, int j) 
    int temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;

最外层的 for 循环每经过一轮，剩余数字中的最大值就会被移动到当前轮次的最后一位，中途也会有一些相邻的数字经过交换变得有序。总共比较次数是 (n-1)+(n-2)+(n-3)+…+1。

这种写法相当于相邻的数字两两比较，并且规定：“谁大谁站右边”。经过 n-1 轮，数字就从小到大排序完成了。整个过程看起来就像一个个气泡不断上浮，这也是“冒泡排序法”名字的由来。

添加主函数：

public static void main(String[] args) 
    int[] arr = 5,3,6,2,1,8,9,7,4;
    Solution.bubbleSort(arr);
    System.out.println(Arrays.toString(arr));

运行结果如下：

冒泡排序的第二种写法

第二种写法是在第一种写法的基础上改良而来的：

public static void bubbleSort(int[] arr) 
    // 初始时 swapped 为 true，否则排序过程无法启动
    boolean swapped = true;
    for (int i = 0; i < arr.length - 1; i++) 
        // 如果没有发生过交换，说明剩余部分已经有序，排序完成
        if (!swapped) 
        	break;
        // 设置 swapped 为 false，如果发生交换，则将其置为 true
        swapped = false;
        for (int j = 0; j < arr.length - 1 - i; j++) 
            if (arr[j] > arr[j + 1]) 
                // 如果左边的数大于右边的数，则交换，保证右边的数字最大
                swap(arr, j, j + 1);
                // 表示发生了交换
                swapped = true;
            
        
    

// 交换元素
private static void swap(int[] arr, int i, int j) 
    int temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;

最外层的 for 循环每经过一轮，剩余数字中的最大值仍然是被移动到当前轮次的最后一位。这种写法相对于第一种写法的优点是：如果一轮比较中没有发生过交换，则立即停止排序，因为此时剩余数字一定已经有序了。

看下动图演示：

图中可以看出：

• 第一轮排序将数字 66 移动到最右边；
• 第二轮排序将数字 55 移动到最右边，同时中途将 11 和 22 排了序；
• 第三轮排序时，没有发生交换，表明排序已经完成，不再继续比较。

冒泡排序的第三种写法

第三种写法比较少见，它是在第二种写法的基础上进一步优化：

public static void bubbleSort(int[] arr) 
    boolean swapped = true;
    // 最后一个没有经过排序的元素的下标
    int indexOfLastUnsortedElement = arr.length - 1;
    // 上次发生交换的位置
    int swappedIndex = -1;
    while (swapped) 
        swapped = false;
        for (int i = 0; i < indexOfLastUnsortedElement; i++) 
            if (arr[i] > arr[i + 1]) 
                // 如果左边的数大于右边的数，则交换，保证右边的数字最大
                swap(arr, i, i + 1);
                // 表示发生了交换
                swapped = true;
                // 更新交换的位置
                swappedIndex = i;
            
        
        // 最后一个没有经过排序的元素的下标就是最后一次发生交换的位置
        indexOfLastUnsortedElement = swappedIndex;
    

// 交换元素
private static void swap(int[] arr, int i, int j) 
    int temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;

经过再一次的优化，代码看起来就稍微有点复杂了。最外层的 while 循环每经过一轮，剩余数字中的最大值仍然是被移动到当前轮次的最后一位。

在下一轮比较时，只需比较到上一轮比较中，最后一次发生交换的位置即可。因为后面的所有元素都没有发生过交换，必然已经有序了。

当一轮比较中从头到尾都没有发生过交换，则表示整个列表已经有序，排序完成。

比如说：从5元素数组，后2位是排好序的，2,3,1,4,5，遍历到元素4，indexOfLastUnsortedElement 被标记，下次遍历到元素1的位置再冒泡就行。

时间复杂度 & 空间复杂度分析

冒泡排序从 1956 年就有人开始研究，之后经历过多次优化。它的空间复杂度为 O(1)，时间复杂度为 O(n^2)，第二种、第三种冒泡排序由于经过优化，最好的情况下只需要 O(n) 的时间复杂度。

最好情况：在数组已经有序的情况下，只需遍历一次，由于没有发生交换，排序结束。

最差情况：数组顺序为逆序，每次比较都会发生交换。

但优化后的冒泡排序平均时间复杂度仍然是 O(n^2)，所以这些优化对算法的性能并没有质的提升。正如 Donald E. Knuth（19741974 年图灵奖获得者）所言：“冒泡排序法除了它迷人的名字和导致了某些有趣的理论问题这一事实外，似乎没有什么值得推荐的。”

小技巧

两数交换技巧

一般来说，交换数组中两个数字的函数如下：

int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;

但在大厂面试中，有一道非常经典的数字交换题目：如何在不引入第三个中间变量的情况下，完成两个数字的交换。

这里可以用到一个数学上的技巧：

arr[j + 1] = arr[j + 1] + arr[j];
arr[j] = arr[j + 1] - arr[j];
arr[j + 1] = arr[j + 1] - arr[j];

除了这种先加后减的写法，还有一种先减后加的写法：

arr[j + 1] = arr[j] - arr[j + 1];
arr[j] = arr[j] - arr[j + 1];
arr[j + 1] = arr[j + 1] + arr[j];

但这两种方式都可能导致数字越界。

更好的方案是通过位运算完成数字交换：

如下面代码：

arr[i] = arr[i] ^ arr[j];
arr[j] = arr[j] ^ arr[i];
arr[i] = arr[i] ^ arr[j];