冒泡排序

冒泡排序的英文Bubble Sort，是一种最基础的交换排序。
这种排序算法的每一个元素都可以像小气泡一样，根据自身大小，一点一点向着数组的一侧移动。

冒泡算法的运作规律如下：

①、比较相邻的元素。如果第一个比第二个大，就交换他们两个。

②、对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数（也就是第一波冒泡完成）。

③、针对所有的元素重复以上的步骤，除了最后一个。

④、持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

原始的冒泡排序是稳定排序。由于该排序算法的每一轮要遍历所有元素，轮转的次数和元素数量相当，所以时间复杂度是O（N^2） 。

java实现冒泡排序算法:

public static void sort(int[] arr) {
        int length = arr.length;
        for (int i = 0; i < length - 1; i++) {
            for (int j = 0; j < length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                   //交换
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }

冒泡排序是由两个for循环构成，第一个for循环的变量 i 表示总共需要多少轮比较，第二个for循环的变量 j 表示每轮参与比较的元素下标【0,1，…，length-i】，因为每轮比较都会出现一个最大值放在最右边，所以每轮比较后的元素个数都会少一个，这也是为什么 j 的范围是逐渐减小的

===优化，在经过一些轮次的时候，数据已经是有序情况下，就不再需要进行后续的循环比较。

代码版本二：

//判断已有排序的话 后续不需要执行
    public static void sort2(int[] arr) {
        int length = arr.length;
        for (int i = 0; i < length - 1; i++) {
            //有序标识，每轮开始的时候是true
            boolean isSorted = true;
            for (int j = 0; j < length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                    //元素需要交换 所以不是排序好的,标记变为fasle
                    isSorted = false;
                }
            }
            if (isSorted) {
                break;
            }
        }
    }

优化三：针对已经排序好的数组，实际有的序区域大于第二个循环需要排序的数据：

    //判断已有排序的话 后续不需要执行 判断有序边界
    public static void sort3(int[] arr) {
        int length = arr.length;
        //无序数列的边界，每次比较只需要比到这里为止
        int sirtedBorder = length - 1;
        //最后一次交换的位置
        int lastExchangeIndex = 0;
        for (int i = 0; i < length - 1; i++) {
            //有序标记，每一轮的初始是true
            boolean isSorted = true;

            for (int j = 0; j < sirtedBorder; j++) {
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                    //有元素交换，所以不是有序，标记变为false
                    isSorted = false;
                    //把无序数列的边界更新为最后一次交换元素的位置
                    lastExchangeIndex = j;
                }
            }
            sirtedBorder = lastExchangeIndex;
            if (isSorted) {
                break;
            }
        }
    }

sortBorder就是无序数列的边界。每一轮排序过程中，sortBorder之后的元素就完全不需要比较了，肯定是有序的。

参考：https://mp.weixin.qq.com/s/wO11PDZSM5pQ0DfbQjKRQA