常见排序算法02--冒泡排序

核心思想

重复地走访过要排序的元素列，依次比较两个相邻的元素，如果他们的顺序（如从大到小、首字母从A到Z）错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素已经排序完成。

排序流程

1. 将序列当中的左右元素，依次比较，若果左边元素比右边元素大，则交换，保证右边的元素始终大于左边的元素；（ 第一轮结束后，序列最后一个元素一定是当前序列的最大值；）
2. 对序列当中剩下的n-1个元素再次执行步骤1。

举例说明

排序数组 [16，12ᴬ，14，7，12ᴮ，8] （注：12ᴬ与12ᴮ是为了标记两个的位置）

1. 第一次
   16 > 12ᴬ =》16 与 12ᴬ 交换位置 =》 16 > 14 =》16 与 14 交换位置 =》 16 > 7 =》16 与 7 交换位置 16 > 12ᴮ =》16 与12ᴮ 交换位置 16 > 8 =》16与 8 交换位置 =》循环结束，此时数组变为 [12ᴬ，14，7，12ᴮ，8，16]
2. 第二次
   12ᴬ < 14 =》 不做操作，循环继续 =》 14 > 7 =》14 与 7 交换位置 =》 14 > 12ᴮ =》14 与 12ᴮ 交换位置 14 > 8 =》14 与 8 交换位置 =》循环结束，此时数组变为 [12ᴬ，7，12ᴮ，8，14，16]
3. 第三次
   重复以上操作第三次循环结束数组变为 [12ᴬ，7，8，12ᴮ，14，16]
4. 第四次
   重复以上操作第三次循环结束数组变为 [7，8，12ᴬ，12ᴮ，14，16]
5. 第五次
   重复以上操作第三次循环结束数组变为 [7，8，12ᴬ，12ᴮ，14，16]

代码实现

    public static void bubbleSort(int[] list) {
        int temp;//临时变量负责交换
        for (int i = 1; i <= list.length; i++) {//外层循环,控制遍历次数 一共需要遍历n-1次
            for (int j = 0; j < list.length - i; j++) {//每次循环结束,后面已经有序,所以每次交换只需循环到上一次的前一位
                if (list[j] > list[j + 1]) {//如果左边大于右边,则交换位置
                    temp = list[j];
                    list[j] = list[j + 1];
                    list[j + 1] = temp;
                }
            }
        }
    }

总结

1、时间复杂度：无论原数组是否有序，外层循环都需要遍历n-1轮，内层需要循环判断n-1-i次，故时间复杂度为O(n²)。
针对于此，冒泡排序可以进行优化，添加一个flag，判断是否有交换，如果没有交换，则说明数组已经有序，无需在进行遍历，可以使最好的情况下时间复杂度变为O(n)。优化后的代码如下。

    public static void bubbleSort(int[] list) {
        int temp;//临时变量负责交换
        for (int i = 1; i <= list.length; i++) {//外层循环,控制遍历次数 一共需要遍历n-1次
        	boolean flag = false;
            for (int j = 0; j < list.length - i; j++) {//每次循环结束,后面已经有序,所以每次交换只需循环到上一次的前一位
                if (list[j] > list[j + 1]) {//如果左边大于右边,则交换位置
                    temp = list[j];
                    list[j] = list[j + 1];
                    list[j + 1] = temp;
                    flag=true;
                }
            }
            if(!flag)break;
        }
    }

2、在示例中可以发现排序前后12ᴬ，12ᴮ的位置顺序没有改变，所以冒泡排序是一个稳定的排序方式。