冒牌排序
基本思想
定义：冒泡排序的英文是bubblesort，它是一种基础的交换排序
原理：每次比较两个相邻的元素，将较大的元素交换至右端 (升序排序)
思路：相邻的元素两两比较，当一个元素大于右侧相邻元素时，交换它们的位置；当一个元素小于或等于右侧相邻元素时，位置不变
案例分析：
1、初始的无序数列 {5,8,6,3,9,2,1,7}，希望对其升序排序
2、按照思路分析：
在经过第一轮交换后，最大的数 9 冒泡到了最右边
到此为止，所有元素都是有序的了，这就是冒泡排序的整体思路。
3、冒泡排序是一种稳定排序，值相等的元素并不会打乱原本的顺序。由于该排序算法的每一轮都要遍历所有元素，总共遍历（元素数量-1）轮，所以平均时间复杂度是O(n2)。
代码实现
第 1 版代码
public static void bubbleSort(int[] arr){
if (arr == null || arr.length == 0) return;
for (int i = 0; i < arr.length - 1; i++) {
for (int j = 0; j < arr.length - 1 -i; j++) {
int tmp = 0;
//升序排序>,降序排序<
if (arr[j] > arr[j + 1]){
tmp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = tmp;
}
}
}
}
使用双循环进行排序。外部循环控制所有的回合，内部循环实现每一轮的冒泡处理，先进行元素比较，再进行元素交换。
第 2 版代码
仍以无序数列 {5,8,6,3,9,2,1,7}为例，我们发现在第 6 轮的时候，数列已经是有序了，但冒泡排序仍然进行了第7轮，可以做一个小优化，在外层循环设置一个哨兵标记isSorted，默认有序，内层循环如果发生交换，则仍为无序
public static void bubbleSort(int[] arr){
if (arr == null || arr.length == 0) return;
for (int i = 0; i < arr.length - 1; i++) {
//是否已经有序的标记，默认有序
boolean isSorted = true;
for (int j = 0; j < arr.length - 1 -i; j++) {
int tmp = 0;
//升序排序>,降序排序<
if (arr[j] > arr[j + 1]){
tmp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = tmp;
//发生元素交换，序列仍是无序状态
isSorted = false;
}
}
if (isSorted){
break;
}
}
}
以isSorted作为标记。如果在本轮排序中，元素有交换，则说明数列无序；如果没有元素交换，则说明数列已然有序，然后直接跳出大循环。
第 3 版代码
以新的无序数列 {3,4,2,1,6,7,8,9}为例，发现前半部分是无序的，而后半部分[6 ,7 ,8 ,9]是有序区间
如果以上面的第2版代码执行，会发现只有前半部分的比较是有意义的，而后半部分的有序区间的比较是无意义的
怎么避免这种情况？那么可以在每一轮的排序后，记录下来最后一次元素交换的位置，该位置即为无序数列的边界，再往后就是有序区
public static void bubbleSort(int[] arr){
if (arr == null || arr.length == 0) return;
//记录记录下来最后一次元素交换的位置
int lastExchangeIndex = 0;
//无序数列的边界，每次比较只需要比到这里为止
int sortBorder = arr.length-1;
for (int i = 0; i < arr.length - 1; i++) {
//是否已经有序的标记，默认有序
boolean isSorted = true;
for (int j = 0; j < sortBorder; j++) {
int tmp = 0;
//升序排序>,降序排序<
if (arr[j] > arr[j + 1]){
tmp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = tmp;
//发生元素交换，序列仍是无序状态
isSorted = false;
//更新为最后一次交换元素的位置
lastExchangeIndex = j;
}
}
//更新无序数列的边界
sortBorder = lastExchangeIndex;
if (isSorted){
break;
}
}
}
在第3版代码中，sortBorder就是无序数列的边界。在每一轮排序过程中，处于sortBorder之后的元素就不需要再进行比较了，肯定是有序的
算法升级
分析
冒泡算法的每一轮都是从左到右来比较元素，进行单向的位置交换的，是单向的
以新的无序数列 {2,3,4,5,6,7,8,1}为例，按照冒泡排序的算法，排序过程如下：
事实上，前面的[2，3，4，5，6，7，8]已经是有序了，只有元素1的位置不正确，却要进行7轮交换。可以将算法从单向交换改为双向交换，排序过程就像钟摆一样，第1轮从左到右，第2轮从右到左，第3轮再从左到右……，这就是鸡尾酒排序.
鸡尾酒排序
图解鸡尾酒排序：
经过2轮交换（虽然实际上已经有序，但是流程并没有结束），进入第3轮交换从左到右进行，1和2比较，位置不变；2和3比较，位置不变；3和4比较，位置不变……6和7比较，位置不变。
没有元素位置进行交换，证明已经有序，排序结束。
public static void cockTailSort(int[] arr){
if (arr == null || arr.length == 0) return;
// 记录右侧最后一次交换的位置
int lastRightExchangeIndex = 0;
// 记录左侧最后一次交换的位置
int lastLeftExchangeIndex = 0;
// 无序数列的右边界，每次比较只需要比到这里为止
int rightSortBorder = arr.length - 1;
// 无序数列的左边界，每次比较只需要比到这里为止
int leftSortBorder = 0;
//i设置为1，代表从第1轮开始
for (int i = 1; i < arr.length; i++) {
boolean isSorted = true;
//奇数，从左到右
if (i % 2 != 0) {
for (int j = leftSortBorder; j < rightSortBorder; j++) {
if (arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
//发生元素交换，序列仍是无序状态
isSorted = false;
//更新为右侧最后一次交换元素的位置
lastRightExchangeIndex = j;
}
}
} else {
//偶数，从右到左
for (int j = rightSortBorder; j > leftSortBorder; j--) {
if (arr[j] < arr[j - 1]) {
int temp = arr[j];
arr[j] = arr[j - 1];
arr[j - 1] = temp;
//发生元素交换，序列仍是无序状态
isSorted = false;
//更新为左侧最后一次交换元素的位置
lastLeftExchangeIndex = j;
}
}
}
//更新无序数列的左边界
leftSortBorder = lastLeftExchangeIndex;
//更新无序数列的右边界
rightSortBorder = lastRightExchangeIndex;
if (isSorted) {
break;
}
}
}
优缺点：鸡尾酒排序的优点是能够在特定条件下，减少排序的回合数；而缺点也很明显，就是代码量几乎增加了1倍。
应用场景：无序数列中大部分元素已经有序
参考图书：《漫画算法—小灰的算法之旅》
欢迎关注我的掘金