【基础算法】冒泡排序法

public void sort(int[] a) {
    if (a == null || a.length == 0) return;
    // 外层的循环代表访问数组的次数，而不是遍历数组中元素的次数
    for (int i = 0; i < a.length - 1; i++) {
        boolean flag = true;
        // 内层的循环是为了实现相邻两元素的交换
        // -1 为了防止溢出，-i 是因为沉到底部的元素是已经被排序好的，不需要再排序了
        for (int j = 0; j < a.length - 1 - i; j++) {
            if (a[j] > a[j + 1]) {
                flag = false;
                Common.sweap(a, j, j + 1);
            }
        }
        if (flag) {
            break;
        }
    }
}

在实现的时候，可以考虑优化，即用一个标志来判断，在每一次的遍历中，如果没有发生过元素的交换，则表示当前序列已经是有序的了，此时就可以直接退出遍历，达到优化的效果。

这是一种稳定的排序。

时间复杂度

最好情况：O(n)
最坏情况：O(n²)
平均情况：O(n²)

空间复杂度
O(1)

---

额外补充：鸡尾酒排序

来自维基百科的解释：

鸡尾酒排序等于是冒泡排序的轻微变形。不同的地方在于从低到高然后从高到低，而冒泡排序则仅从低到高去比较序列里的每个元素。他可以得到比冒泡排序稍微好一点的性能，原因是冒泡排序只从一个方向进行比对（由低到高），每次循环只移动一个项目。

以序列(2,3,4,5,1)为例，鸡尾酒排序只需要访问一次序列（这里说的访问序列的次数，而不是遍历数组元素的次数，即两种实现最外层的那个大循环的次数）就可以完成排序，但如果使用冒泡排序则需要四次。但是在随机数序列的状态下，鸡尾酒排序与冒泡排序的效率都很差劲。

通俗的说，就是在每一次数组的访问过程中，先从左到右，把当前数组最大的元素沉到末尾，然后取去除末尾元素剩余的数组，在该数组中，再从右到左，将最小的放到首端。

如此往复，直至排序完成。这样，在遍历元素的范围，就限制在了去除两端已经排序好的元素之间。（原本的实现是单边的，遍历的范围的总是从整个数组的第一个元素到末端已经排序好的元素之间）

public void cocktailSort(int[] a) {
    if (a == null || a.length == 0) return;
    int left = 0, right = a.length - 1;
    // while 循环用于访问数组
    while (left < right) {
        boolean flag = true;
        // i 最大为 right - 1, 所以当 i 最大是 +1 不会溢出
        // 下面的那个遍历同理
        for (int i = left; i < right; i++) {
            if (a[i] > a[i + 1]) {
                flag = false;
                Common.sweap(a, i, i + 1);
            }
        }
        if (flag) break;
        
        --right;
        
        flag = true;
        for (int i = right; i > left; i--) {
            if (a[i] < a[i - 1]) {
                flag = false;
                Common.sweap(a, i, i - 1);
            }
        }
        if (flag) break;
        
		++left;
    }
}

时间复杂度跟原本的实现是一样的，因此对于同一序列，循环的次数是一样的。只不过是鸡尾酒排序法会减少外层循环访问数组的次数。