冒泡排序,顾名思义就像水沸腾时,沸腾的水泡自下而上,由大到小的往水面沸腾.
从大一接触唐浩强爷爷的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));
}
}
【参考文章】