排序算法之冒泡排序

算法原理

1. 从头开始比较相邻的两个元素，如果第一个比第二个大，就进行交换。一次循环后，最后的元素就会是最大的数。
2. 重复步骤1，只到倒数第二个结束。以此类推，只到只剩第一个元素比较结束。

图解

代码实现

public class BubbleSort {

    public static void main(String[] args) {
        int[] arr = {6, 5, 8, 4, 2, 7};
        bubbleSort(arr);
    }

    /**
     * 冒泡排序
     */
    public static void bubbleSort(int[] arr) {
        int temp;
        boolean flag; // 这个值很巧妙
        for (int i = 0; i < arr.length - 1; i++) {
            //设定一个标记，当一次循环后，若是true,说明数组已是有序数组
            boolean flag = true;
            //角标从0开始，相邻两个进行比较，一次循环（最多互换arr.length-1次）将最大值放到数组最右边
            for (int j = 0; j < arr.length - 1 - i; j++) {
                //升序排序
                if (arr[j] > arr[j + 1]) {
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                    flag = false;
                }
            }

            System.out.println("printTimes:" + i);
            for (int a : arr) {
                System.out.print(a + " ");
            }
            System.out.println("");

            //任意一次循环后，若是true则直接退出循环，说明已是有序数组。
            if (flag) {
                break;
            }
        }
    }
}

打印结果

printTimes:0
5 6 4 2 7 8 
printTimes:1
5 4 2 6 7 8 
printTimes:2
4 2 5 6 7 8 
printTimes:3
2 4 5 6 7 8 
printTimes:4
2 4 5 6 7 8 

排序算法稳定性

如果两个相等的元素没有相邻，那么即使通过前面的两两交换把两个相邻起来，这时候也不会交换， 所以相同元素的前后顺序并没有改变。
所以冒泡排序是一种稳定排序算法。

总结

从代码上看，冒泡排序和选择排序一样都用了两层循环，即时间复杂度是相同的即O(n²).但冒泡排序在内层循环中可能会不停的交换位置，而选择排序只是在外层循环中交换 一次位置，所以选择排序在时间效率上会明显高于冒泡排序。
如果数组本身是有序的，则冒泡排序可以只循环一次就可以退出循环，并确定是有序数列了 而这时选择排序还需要多次循环。此时冒泡的效率较高，但这种情况极少。