冒泡排序，顾名思义就像水沸腾时，沸腾的水泡自下而上，由大到小的往水面沸腾.
从大一接触唐浩强爷爷的C语言，老师讲的第一个排序算法便是冒泡排序.
一、冒泡思想
冒泡排序是交换排序的一种，在基础排序算法中还有快速排序.
冒泡排序（Bubble Sort）也是一种简单直观的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序有误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端，故名“冒泡排序”.
- 比较相邻的元素。如果第一个比第二个大，就交换他们两个
- 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
- 针对所有的元素重复以上的步骤，除了最后一个。
- 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
- 将天平放在序列的右端，并比较天平左右的数字
- 在这种情况下我们比较 3 和 8
- 比较后如果右边的数字较小，则被交换
- 因为 8 大于 3 ，所以数字不用交换
- 比较完成后，将天平向左移动一个位置，比较数字
- 因为 3 大于 2 ，所以数字不用交换
- 比较完成后，逐一移动天平，比较数字
- 此时 2 小于 4 ，所以左右的数字互相交换
- 重复同样的操作，直到天平移动到左端
- 。。。。。。
- 天平到达左端
- 经过上述的操作，数列中最小的数字已经移动到左端
- 将天平返回右端
- 重复相同的操作，直到所有数字都被排序
以上动画演示及详细解释来源于微型公众号【五分钟学算法】，很多基础的排序算法和数据结构动图解释的很清楚，推荐一波
二、冒泡实现及优化
通过以上的讲解，相信大家对冒泡排序的思维有一定的了解。 我们通过一个简单的例子，用代码来实现
我们通过这8个数从小到大来排序：
【数据结构和算法动态可视化网站】，动图演示很形象具体
代码使用双层循环进行排序，外部循环控制所有趟数，内部循环实现每一轮的冒泡处理。先进行元素比较，再进行元素交换
1. 基础版本
import java.util.Arrays;
/**
* @Author: Mr.Q
* @Date: 2019-10-13 09:25
* @Description:基础冒泡排序
*/
public class BasicBubbleSort {
/**
* 自上往下冒泡
* @param arr
*/
public static void bubbleSort(int[] arr) {
for(int i = 0; i < arr.length - 1; i++) {
for(int j = 0; j < arr.length - 1 - i; j++) {
if(arr [j] > arr [j + 1]) {
int temp = arr [j];
arr [j] = arr [j+1];
arr [j+1] = temp;
}
}
}
}
public static void main(String[] args) {
int[] array = new int [] {5, 8, 6, 3, 9, 2, 1, 7};
bubbleSort(array);
System.out.println("The Bubble Sort is : " + Arrays.toString(array));
}
}
自下往上冒泡-----由大到小排列
/**
* 自下往上冒泡
* @param arr
*/
public static void bubbleSort_A(int[] arr) {
for(int i = arr.length - 1 ; i > 0; i--) {
for(int j = 0; j < i; j++) {
if(arr [j] > arr [j + 1]) {
int temp = arr [j];
arr [j] = arr [j+1];
arr [j+1] = temp;
}
}
}
}
2. 升级版本
import java.util.Arrays;
/**
* @Author: Mr.Q
* @Date: 2019-10-13 10:24
* @Description:优化的冒泡排序,增加标志位,如果有序则不交换
*/
public class OptimalBubble {
public static void bubbleSort(int[] arr) {
boolean flag = false;
for(int i = 0; i < arr.length - 1; i++) {
for(int j = 0; j < arr.length - 1 - i; j++) {
if(arr [j] > arr [j + 1]) {
int temp = arr [j];
arr [j] = arr [j+1];
arr [j+1] = temp;
//此趟排序没有进行数值交换
flag = true;
}
}
//在一趟排序中没有发生过交换
if(!flag) {
break;
}else {
//重置flag,进行下次判断
flag = false;
}
}
}
public static void main(String[] args) {
int[] array = new int [] {5, 8, 6, 3, 9, 2, 1, 7};
bubbleSort(array);
System.out.println("The Bubble Sort is : " + Arrays.toString(array));
}
}
与基础版本相比较，升级版本利用flag作为标记。
在内层每一轮的排序中，如果有元素发生了交换，则flag = true，说明数列无序；
如果元素有序，此时flag为false，!flag为 true，此轮排序结束，进入外层下一轮循环
我们再换一个新的数列，它的前半部分无序（3，4，2，1），后半部分有序（5，6，7，8），并且后半部分的最小值也大于前半部分的最大值，就是只用排前半部分就好了，直接把它放到后半部前面就好。
此时，还用版本2的升级版也做了一半的无用功，还有待需要继续优化
挤牙膏，高极版的来了…
3. 高级版
public class OptimalPlusBubbleSort {
public static void bubbleSortPlus(int[] arr) {
boolean flag = false;
for(int i = 0; i < arr.length - 1; i++) {
//sortBorder之后的元素一定有序
//sortBorder定义在内外层循环之间
int sortBorder = arr.length - 1;
for(int j = 0; j < sortBorder; j++) {
if(arr [j] > arr [j + 1]) {
int temp = arr [j];
arr [j] = arr [j+1];
arr [j+1] = temp;
//把无序数列的边界更新为最后一次交换元素的位置
sortBorder = j;
//此趟排序没有进行数值交换
flag = true;
}
}
//在一趟排序中没有发生过交换
if(!flag) {
break;
}else {
//重置flag,进行下次判断
flag = false;
}
}
}
public static void main(String[] args) {
int[] array = new int [] {3, 4, 2, 1, 5, 6, 7, 8};
bubbleSortPlus(array);
System.out.println("The Bubble Sort is : " + Arrays.toString(array));
}
}
因为此时后半段数列有序，当把元素4放到5之前时，sortBorder = 3，后面便不再比较
这样，相对于上一个版本，针对这种半有序，半无序的数列效率又有提高了不少呢！
这次，我要排这个呢？好像上面的效率又不行了…
上面的 版本3–高级版 其实就可以了，但是，针对此还有一中特定的排序算法（谁发明的，此时我要膜拜三分钟）
4. 鸡尾酒排序
冒泡排序的每一轮都是从左到右来比较元素，是单向的位置交换；
但是，鸡尾酒排序元素比较和交换是双向的
排序过程如下：
第1趟：
和基础冒泡排序一样，从左到右走一趟，把8沉底
第2趟：
从右往左冒泡（从倒数第二位开始）
第3趟：
继续从左向右走（虽然有序，但继续判断，类似于最基础的冒泡）
第4趟：
从右往左（从倒数第三位开始）
直到没有元素再发生交换而结束
public class CocktailSort {
public static void cocktailSort(int[] arr) {
boolean flag = false;
for(int i = 0; i < arr.length / 2; i++) {
//奇数轮,从左向右比较交换
for(int j = 0; j < arr.length - 1; j++) {
if(arr [j] > arr [j + 1]) {
int temp = arr [j];
arr [j] = arr [j+1];
arr [j+1] = temp;
//此趟排序没有进行数值交换
flag = true;
}
}
//在一趟排序中没有发生过交换
if(!flag) {
break;
}else {
//重置flag,进行下次判断
flag = false;
}
//偶数轮,从右向左比较交换
for(int j = arr.length - 1; j > i;j--) {
if(arr [j] < arr [j - 1]) {
int temp = arr [j];
arr [j] = arr [j-1];
arr [j-1] = temp;
//此趟排序没有进行数值交换
flag = true;
}
}
//在一趟排序中没有发生过交换
if(!flag) {
break;
}else {
//重置flag,进行下次判断
flag = false;
}
}
}
public static void main(String[] args) {
int[] array = new int [] {2, 3, 4, 5, 6, 7, 8, 1};
CocktailSort(array);
System.out.println("The Bubble Sort is : " + Arrays.toString(array));
}
}
【参考文章】
