图解排序算法(01) -- 你不知道的冒泡排序

1、初识冒泡排序

冒泡排序的英文是bubble sort，它是一种基础的交换排序；冒泡排序每一个元素都可以根据自身大小，一点一点地向着数组的一侧移动。
例：
有8个数字组成一个无序数列{5,8,6,3,9,2,1,7}，希望按照从小到大的顺序对其进行排序

按照冒泡排序的思想，要把相邻的元素两两比较，

• 当一个元素大于右侧相邻元素时，交换它们的位置
• 当一个元素小于或等于右侧相邻元素时，位置不变

详细过程如下：

经过上面的操作，元素9作为数列中最大的元素移动了最右侧，此时冒泡排序的第1轮就结束了；
数列最右侧元素9的位置可以认为是一个有序区域，有序区域目前只有1个元素，此时排序如下图：

第2轮排序：

第2轮排序结束后，数列右侧的有序区有了2个元素，顺序如下图：

继续如上面操作，第3轮到第7轮的状态如下：

到此为止，所有元素都是有序的了，这就是冒泡排序的整体思路。
冒泡排序是一种稳定排序，值相等的元素并不会打乱原本的顺序；由于该排序算法的每一轮都要遍历所有元素，总共遍历（元素数量-1）轮，所以平均时间复杂度是O(n²)

2、冒泡排序的代码实现

Code:

import java.util.Arrays;
public class maopao {
    //冒泡排序方法实现
    public static void sort(int array[]){
        for(int i = 0;i < array.length - 1;i++){
            for(int j = 0;j < array.length -i -1 ;j++){
                int tmp = 0;
                if(array[j] > array[j+1]){
                    tmp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = tmp;
                }
            }
        }
    }
    public static void main(String[] args){
        int[] array = new int[]{5,8,6,3,9,2,1,7};
        System.out.println("排序前 ：" + Arrays.toString(array));
        sort(array);
        System.out.println("排序后 ：" + Arrays.toString(array));
    }
}

编译输出：【使用双循环进行排序：外部循环控制所有的回合，内部循环实现每一轮的冒泡处理，先进行元素比较，再进行元素交换】

3、冒泡排序的初步优化

当排序算法分别执行到第6、第7轮时，数列状态如下：

经过第6轮排序后，整个数列已然是有序的了。可是排序算法 仍然继续执行第7轮排序，所以如果能判断出数列已经有序，并做出标记，那么剩下的几轮排序就不必执行了，就可以提前结束排序：
改进后的Code:

import java.util.Arrays;
public class maopao {
    //冒泡排序方法实现
    public static void sort(int array[]){
        for(int i = 0;i < array.length - 1;i++){
            //有序标记，每一轮的初始值都是true
            boolean isSorted = true;
            for(int j = 0;j < array.length -i -1 ;j++){
                int tmp = 0;
                if(array[j] > array[j+1]){
                    tmp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = tmp;
             //因为有元素进行交换，所以不是有序的，标记变为false
                    isSorted = false;
                }
            }
            if(isSorted){
                break;
            }
        }
    }
    public static void main(String[] args){
        int[] array = new int[]{5,8,6,3,9,2,1,7};
        System.out.println("排序前 ：" + Arrays.toString(array));
        sort(array);
        System.out.println("排序后 ：" + Arrays.toString(array));
    }
}

编译输出：【利用布尔变量isSorted作为标记。如果在本轮排序中元素有交换，则说明数列无序；如果没有元素交换，则说明数列已然有序，可以直接跳出大循环】

4、冒泡排序的进阶优化

以一个新的数列为例：
这个数列的特点是前半部分的元素（3、4、2、1）无序，后半部分的元素（5、 6、7、8）按升序排列，并且后半部分元素中的最小值也大于前半部分元素的最大值

按照冒泡排序的思路来进行排序，效果如下：
【第一轮】

元素4和5比较，发现4小于5，所以位置不变；
元素5和6比较，发现5小于6，所以位置不变；
元素6和7比较，发现6小于7，所以位置不变；
元素7和8比较，发现7小于8，所以位置不变；
第1轮结束，数列有序区包含1个元素，如下图所示：

【第二轮】

元素3和2比较，发现3大于2，所以3和2交换。
元素3和4比较，发现3小于4，所以位置不变。
元素4和5比较，发现4小于5，所以位置不变。
元素5和6比较，发现5小于6，所位位置不变。
元素6和7比较，发现6小于7，所以位置不变。
元素7和8比较，发现7小于8，所以位置不变。
第2轮结束，数列有序区包含2个元素，如下图所示：

【其实右面的许多元素已经是有序的了，可是每一轮还是白白地比较了许多次】
【优化关键点】：在于对数列有序区的界定
按照现有的逻辑，有序区的长度【紫色区域】和排序的轮数是相等的：例如第1轮排序过后的 有序区长度是1，第2轮排序过后的有序区长度是2 ……但数列真正的有序区可能会大于这个长度，如上述例子中在第2轮排序时，后面的5个元素实际上都已经属于有序区了。因此后面的多次元素比较是没有意义的。
【解决方案】：
可以在每一轮排序后，记录下来最后一次元素交换的位置，该位置即为无序数列的边界，再往后就是有序区了
改进后的Code:

import java.util.Arrays;
public class maopao {
    //冒泡排序方法实现
    public static void sort(int array[]){
        //记录最后一次交换的位置
        int lastExchangeIndex = 0;
        //无序数列的边界，每次比较只需要比到这里为止
        int sortBorder = array.length - 1;
        for(int i = 0;i < array.length - 1;i++){
            //有序标记，每一轮的初始值都是true
            boolean isSorted = true;
            for(int j = 0;j < array.length -i -1 ;j++){
                int tmp = 0;
                if(array[j] > array[j+1]){
                    tmp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = tmp;
                    //因为有元素进行交换，所以不是有序的，标记变为false
                    isSorted = false;
                    // 更新为最后一次交换元素的位置
                    lastExchangeIndex = j;
                }
            }
            sortBorder = lastExchangeIndex;
            if(isSorted){
                break;
            }
        }
    }
    public static void main(String[] args){
        int[] array = new int[]{3,4,2,1,5,6,7,8};
        System.out.println("排序前 ：" + Arrays.toString(array));
        sort(array);
        System.out.println("排序后 ：" + Arrays.toString(array));
    }
}

编译输出：【sortBorder是无序数列的边界；在每一轮排序过程中，在sortBorder之后的元素就不需要再进行比较了，因为后面肯定是有序的】

———————————————————————————————————————
内容来源：《漫画算法》
关注公众号，回复 【算法】，获取高清算法书！