冒泡排序
思想
- 基本思想: 冒泡排序，类似于水中冒泡，较大的数沉下去，较小的数慢慢冒起来，假设从小到大，即为较大的数慢慢往后排，较小的数慢慢往前排。
- 直观表达，每一趟遍历，将一个最大的数移到序列末尾。
算法描述
-
比较相邻的元素，如果前一个比后一个大，交换之。
-
第一趟排序第1个和第2个一对，比较与交换，随后第2个和第3个一对比较交换，这样直到倒数第2个和最后1个，将最大的数移动到最后一位。
-
第二趟将第二大的数移动至倒数第二位
...
因此需要n-1趟；
代码实现
public static void main(String[] args) {
int[] arr = {2, 5, 1, 3, 8, 5, 7, 4, 3};
bubbleSort(arr);
System.out.println("最终排序结果：" + Arrays.toString(arr));
}
/**
* 冒泡排序
*
* @param arr 需要被排序的数组
*/
private static void bubbleSort(int[] arr) {
if (arr == null || arr.length < 2) {
return;
}
//开辟一个新的空间，存放交换的中间值
int temp = 0;
/**
* 外层冒泡的轮数
* 因为有arr.length个数组元素，所以只需要比较arr.length-1轮
*/
for (int i = 0; i < arr.length - 1; i++) {
System.out.format("第 %d 轮:\n", i + 1);
/**
* 里面内层依次比较,替换
* arr.length-i因为每一次排序都会将最大值放到最后,所以排序完i轮，就说明i个数已经排序好了，就不需要再比较，替换
* arr.length-1因为我们是使用下标j元素和j+1元素比较，防止下标越界
*/
for (int j = 0; j < arr.length - i - 1; j++) {
/**
* 判断下标j和下标j+1的大小
* 当我们改变下标j和j+1判断的符号为<，就会从大到小排序
*/
if (arr[j] > arr[j + 1]) {
/**
* 当j的值大于j+1的值，交换j和j+1
* 则比较大的值放到后面
*/
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
System.out.format("第 %d 轮的第 %d 次交换：", i + 1, j + 1);
System.out.format(Arrays.toString(arr));
System.out.println("");
}
System.out.format("第 %d 轮最终结果：", i + 1);
System.out.format(Arrays.toString(arr));
System.out.println("\n#########################");
}
}
第 1 轮:
第 1 轮的第 1 次交换：[2, 5, 1, 3, 8, 5, 7, 4, 3]
第 1 轮的第 2 次交换：[2, 1, 5, 3, 8, 5, 7, 4, 3]
第 1 轮的第 3 次交换：[2, 1, 3, 5, 8, 5, 7, 4, 3]
第 1 轮的第 4 次交换：[2, 1, 3, 5, 8, 5, 7, 4, 3]
第 1 轮的第 5 次交换：[2, 1, 3, 5, 5, 8, 7, 4, 3]
第 1 轮的第 6 次交换：[2, 1, 3, 5, 5, 7, 8, 4, 3]
第 1 轮的第 7 次交换：[2, 1, 3, 5, 5, 7, 4, 8, 3]
第 1 轮的第 8 次交换：[2, 1, 3, 5, 5, 7, 4, 3, 8]
第 1 轮最终结果：[2, 1, 3, 5, 5, 7, 4, 3, 8]
#########################
第 2 轮:
第 2 轮的第 1 次交换：[1, 2, 3, 5, 5, 7, 4, 3, 8]
第 2 轮的第 2 次交换：[1, 2, 3, 5, 5, 7, 4, 3, 8]
第 2 轮的第 3 次交换：[1, 2, 3, 5, 5, 7, 4, 3, 8]
第 2 轮的第 4 次交换：[1, 2, 3, 5, 5, 7, 4, 3, 8]
第 2 轮的第 5 次交换：[1, 2, 3, 5, 5, 7, 4, 3, 8]
第 2 轮的第 6 次交换：[1, 2, 3, 5, 5, 4, 7, 3, 8]
第 2 轮的第 7 次交换：[1, 2, 3, 5, 5, 4, 3, 7, 8]
第 2 轮最终结果：[1, 2, 3, 5, 5, 4, 3, 7, 8]
#########################
第 3 轮:
第 3 轮的第 1 次交换：[1, 2, 3, 5, 5, 4, 3, 7, 8]
第 3 轮的第 2 次交换：[1, 2, 3, 5, 5, 4, 3, 7, 8]
第 3 轮的第 3 次交换：[1, 2, 3, 5, 5, 4, 3, 7, 8]
第 3 轮的第 4 次交换：[1, 2, 3, 5, 5, 4, 3, 7, 8]
第 3 轮的第 5 次交换：[1, 2, 3, 5, 4, 5, 3, 7, 8]
第 3 轮的第 6 次交换：[1, 2, 3, 5, 4, 3, 5, 7, 8]
第 3 轮最终结果：[1, 2, 3, 5, 4, 3, 5, 7, 8]
#########################
第 4 轮:
第 4 轮的第 1 次交换：[1, 2, 3, 5, 4, 3, 5, 7, 8]
第 4 轮的第 2 次交换：[1, 2, 3, 5, 4, 3, 5, 7, 8]
第 4 轮的第 3 次交换：[1, 2, 3, 5, 4, 3, 5, 7, 8]
第 4 轮的第 4 次交换：[1, 2, 3, 4, 5, 3, 5, 7, 8]
第 4 轮的第 5 次交换：[1, 2, 3, 4, 3, 5, 5, 7, 8]
第 4 轮最终结果：[1, 2, 3, 4, 3, 5, 5, 7, 8]
#########################
第 5 轮:
第 5 轮的第 1 次交换：[1, 2, 3, 4, 3, 5, 5, 7, 8]
第 5 轮的第 2 次交换：[1, 2, 3, 4, 3, 5, 5, 7, 8]
第 5 轮的第 3 次交换：[1, 2, 3, 4, 3, 5, 5, 7, 8]
第 5 轮的第 4 次交换：[1, 2, 3, 3, 4, 5, 5, 7, 8]
第 5 轮最终结果：[1, 2, 3, 3, 4, 5, 5, 7, 8]
#########################
第 6 轮:
第 6 轮的第 1 次交换：[1, 2, 3, 3, 4, 5, 5, 7, 8]
第 6 轮的第 2 次交换：[1, 2, 3, 3, 4, 5, 5, 7, 8]
第 6 轮的第 3 次交换：[1, 2, 3, 3, 4, 5, 5, 7, 8]
第 6 轮最终结果：[1, 2, 3, 3, 4, 5, 5, 7, 8]
#########################
第 7 轮:
第 7 轮的第 1 次交换：[1, 2, 3, 3, 4, 5, 5, 7, 8]
第 7 轮的第 2 次交换：[1, 2, 3, 3, 4, 5, 5, 7, 8]
第 7 轮最终结果：[1, 2, 3, 3, 4, 5, 5, 7, 8]
#########################
第 8 轮:
第 8 轮的第 1 次交换：[1, 2, 3, 3, 4, 5, 5, 7, 8]
第 8 轮最终结果：[1, 2, 3, 3, 4, 5, 5, 7, 8]
#########################
最终排序结果：[1, 2, 3, 3, 4, 5, 5, 7, 8]
复杂度
-
时间复杂度:
-
空间复杂度:
-
稳定
优化
优化一
假设我们现在排序arr[]={1,2,3,4,5,6,7,8,10,9}这组数据，按照上面的排序方式，第一趟排序后将10和9交换已经有序，接下来的8趟排序就是多余的，什么也没做。所以我们可以在交换的地方加一个标记，如果那一趟排序没有交换元素，说明这组数据已经有序，不用再继续下去。
public static void main(String[] args) {
int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 10, 9};
bubbleSort(arr);
System.out.println("最终排序结果：" + Arrays.toString(arr));
}
/**
* 冒泡排序
*
* @param arr 需要被排序的数组
*/
private static void bubbleSort(int[] arr) {
if (arr == null || arr.length < 2) {
return;
}
//开辟一个新的空间，存放交换的中间值
int temp = 0;
/**
* 外层冒泡的轮数
* 因为有arr.length个数组元素，所以只需要比较arr.length-1轮
*/
for (int i = 0; i < arr.length - 1; i++) {
//设置一个标志位
boolean flag = false;
System.out.format("第 %d 轮:\n", i + 1);
/**
* 里面内层依次比较,替换
* arr.length-i因为每一次排序都会将最大值放到最后,所以排序完i轮，就说明i个数已经排序好了，就不需要再比较，替换
* arr.length-1因为我们是使用下标j元素和j+1元素比较，防止下标越界
*/
for (int j = 0; j < arr.length - i - 1; j++) {
/**
* 判断下标j和下标j+1的大小
* 当我们改变下标j和j+1判断的符号为<，就会从大到小排序
*/
if (arr[j] > arr[j + 1]) {
/**
* 当j的值大于j+1的值，交换j和j+1
* 则比较大的值放到后面
*/
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
//发生交换，标志位修改为true
flag = true;
}
System.out.format("第 %d 轮的第 %d 次交换：", i + 1, j + 1);
System.out.format(Arrays.toString(arr));
System.out.println("");
}
System.out.format("第 %d 轮最终结果：", i + 1);
System.out.format(Arrays.toString(arr));
System.out.println("\n#########################");
//如果某一轮，没有交换元素，说明已经有序
if (!flag) {
return;
}
}
}
第 1 轮:
第 1 轮的第 1 次交换：[1, 2, 3, 4, 5, 6, 7, 8, 10, 9]
第 1 轮的第 2 次交换：[1, 2, 3, 4, 5, 6, 7, 8, 10, 9]
第 1 轮的第 3 次交换：[1, 2, 3, 4, 5, 6, 7, 8, 10, 9]
第 1 轮的第 4 次交换：[1, 2, 3, 4, 5, 6, 7, 8, 10, 9]
第 1 轮的第 5 次交换：[1, 2, 3, 4, 5, 6, 7, 8, 10, 9]
第 1 轮的第 6 次交换：[1, 2, 3, 4, 5, 6, 7, 8, 10, 9]
第 1 轮的第 7 次交换：[1, 2, 3, 4, 5, 6, 7, 8, 10, 9]
第 1 轮的第 8 次交换：[1, 2, 3, 4, 5, 6, 7, 8, 10, 9]
第 1 轮的第 9 次交换：[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
第 1 轮最终结果：[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
#########################
第 2 轮:
第 2 轮的第 1 次交换：[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
第 2 轮的第 2 次交换：[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
第 2 轮的第 3 次交换：[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
第 2 轮的第 4 次交换：[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
第 2 轮的第 5 次交换：[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
第 2 轮的第 6 次交换：[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
第 2 轮的第 7 次交换：[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
第 2 轮的第 8 次交换：[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
第 2 轮最终结果：[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
#########################
最终排序结果：[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
优化二
优化一仅仅适用于连片有序而整体无序的数据(例如：1， 2，3 ，4 ，7，6，5)。但是对于前面大部分是无序而后边小半部分有序的数据(1，2，5，7，4，3，6，8，9，10)排序效率也不可观，对于种类型数据，我们可以继续优化。既我们可以记下最后一次交换的位置，后边没有交换，必然是有序的，然后下一次排序从第一个比较到上次记录的位置结束即可。
public static void main(String[] args) {
int[] arr = {1, 2, 5, 7, 4, 3, 6, 8, 9, 10};
bubbleSort(arr);
System.out.println("最终排序结果：" + Arrays.toString(arr));
}
/**
* 冒泡排序
*
* @param arr 需要被排序的数组
*/
private static void bubbleSort(int[] arr) {
if (arr == null || arr.length < 2) {
return;
}
//开辟一个新的空间,存放交换的中间值
int temp = 0;
//设置一个标志位
boolean flag = false;
//用来记录最后一次交换的位置
int pos = 0;
int k = arr.length - 1;
/**
* 外层冒泡的轮数
* 因为有arr.length个数组元素,所以只需要比较arr.length-1轮
*/
for (int i = 0; i < arr.length - 1; i++) {
pos = 0;
flag = false;
System.out.format("第 %d 轮:\n", i + 1);
for (int j = 0; j < k; j++) {
/**
* 判断下标j和下标j+1的大小
* 当我们改变下标j和j+1判断的符号为<,就会从大到小排序
*/
if (arr[j] > arr[j + 1]) {
/**
* 当j的值大于j+1的值,交换j和j+1
* 则比较大的值放到后面
*/
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
//发生交换,标志位修改为true
flag = true;
//记录最后一次交换的位置
pos = j;
}
System.out.format("第 %d 轮的第 %d 次交换：", i + 1, j + 1);
System.out.format(Arrays.toString(arr));
System.out.println("");
}
System.out.format("第 %d 轮最终结果：", i + 1);
System.out.format(Arrays.toString(arr));
System.out.println("\n#########################");
//如果某一轮,没有交换元素,说明已经有序
if (!flag) {
return;
}
//下一次比较到记录位置即可
k = pos;
}
}
第 1 轮:
第 1 轮的第 1 次交换：[1, 2, 5, 7, 4, 3, 6, 8, 9, 10]
第 1 轮的第 2 次交换：[1, 2, 5, 7, 4, 3, 6, 8, 9, 10]
第 1 轮的第 3 次交换：[1, 2, 5, 7, 4, 3, 6, 8, 9, 10]
第 1 轮的第 4 次交换：[1, 2, 5, 4, 7, 3, 6, 8, 9, 10]
第 1 轮的第 5 次交换：[1, 2, 5, 4, 3, 7, 6, 8, 9, 10]
第 1 轮的第 6 次交换：[1, 2, 5, 4, 3, 6, 7, 8, 9, 10]
第 1 轮的第 7 次交换：[1, 2, 5, 4, 3, 6, 7, 8, 9, 10]
第 1 轮的第 8 次交换：[1, 2, 5, 4, 3, 6, 7, 8, 9, 10]
第 1 轮的第 9 次交换：[1, 2, 5, 4, 3, 6, 7, 8, 9, 10]
第 1 轮最终结果：[1, 2, 5, 4, 3, 6, 7, 8, 9, 10]
#########################
第 2 轮:
第 2 轮的第 1 次交换：[1, 2, 5, 4, 3, 6, 7, 8, 9, 10]
第 2 轮的第 2 次交换：[1, 2, 5, 4, 3, 6, 7, 8, 9, 10]
第 2 轮的第 3 次交换：[1, 2, 4, 5, 3, 6, 7, 8, 9, 10]
第 2 轮的第 4 次交换：[1, 2, 4, 3, 5, 6, 7, 8, 9, 10]
第 2 轮的第 5 次交换：[1, 2, 4, 3, 5, 6, 7, 8, 9, 10]
第 2 轮最终结果：[1, 2, 4, 3, 5, 6, 7, 8, 9, 10]
#########################
第 3 轮:
第 3 轮的第 1 次交换：[1, 2, 4, 3, 5, 6, 7, 8, 9, 10]
第 3 轮的第 2 次交换：[1, 2, 4, 3, 5, 6, 7, 8, 9, 10]
第 3 轮的第 3 次交换：[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
第 3 轮最终结果：[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
#########################
第 4 轮:
第 4 轮的第 1 次交换：[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
第 4 轮的第 2 次交换：[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
第 4 轮最终结果：[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
#########################
最终排序结果：[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
优化三
优化二的效率有很大的提升，还有一种优化方法可以继续提高效率。大致思想就是一次排序可以确定两个值，正向扫描找到最大值交换到最后，反向扫描找到最小值交换到最前面。例如：排序数据1，2，3，4，5，6，0
public static void main(String[] args) {
int[] arr = {1, 2, 3, 4, 5, 6, 0};
bubbleSort(arr);
System.out.println("最终排序结果：" + Arrays.toString(arr));
}
/**
* 冒泡排序
*
* @param arr 需要被排序的数组
*/
private static void bubbleSort(int[] arr) {
if (arr == null || arr.length < 2) {
return;
}
int count = 1;
int i, j;
//同时找最大值的最小需要两个下标遍历
int n = 0;
//设置一个标志位
boolean flag = false;
//用来记录最后一次交换的位置
int pos = 0;
int k = arr.length - 1;
/**
* 外层冒泡的轮数
* 因为有arr.length个数组元素,所以只需要比较arr.length-1轮
*/
for (i = 0; i < arr.length - 1; i++) {
pos = 0;
flag = false;
System.out.format("第 %d 轮:\n", i + 1);
//正向寻找最大数
for (j = n, count = 1; j < k; j++) {
if (arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
//发生交换,标志位修改为true
flag = true;
//记录最后一次交换的位置
pos = j;
}
System.out.format("正向第 %d 轮的第 %d 次交换：", i + 1, count++);
System.out.format(Arrays.toString(arr));
System.out.println("");
}
System.out.format("正向第 %d 轮最终结果：", i + 1);
System.out.format(Arrays.toString(arr));
System.out.println("\n#########################");
//如果某一轮,没有交换元素,说明已经有序
if (!flag) {
return;
}
//下一次比较到记录位置即可
k = pos;
//反向寻找最小值
for (j = k, count = 1; j > n; j--) {
int temp = arr[j];
arr[j] = arr[j - 1];
arr[j - 1] = temp;
//发生交换,标志位修改为true
flag = true;
System.out.format("反向第 %d 轮的第 %d 次交换：", i + 1, count++);
System.out.format(Arrays.toString(arr));
System.out.println("");
}
System.out.format("反向第 %d 轮最终结果：", i + 1);
System.out.format(Arrays.toString(arr));
System.out.println("\n#########################");
n++;
//如果某一轮,没有交换元素,说明已经有序
if (!flag) {
return;
}
}
}
第 1 轮:
正向第 1 轮的第 1 次交换：[1, 2, 3, 4, 5, 6, 0]
正向第 1 轮的第 2 次交换：[1, 2, 3, 4, 5, 6, 0]
正向第 1 轮的第 3 次交换：[1, 2, 3, 4, 5, 6, 0]
正向第 1 轮的第 4 次交换：[1, 2, 3, 4, 5, 6, 0]
正向第 1 轮的第 5 次交换：[1, 2, 3, 4, 5, 6, 0]
正向第 1 轮的第 6 次交换：[1, 2, 3, 4, 5, 0, 6]
正向第 1 轮最终结果：[1, 2, 3, 4, 5, 0, 6]
#########################
反向第 1 轮的第 1 次交换：[1, 2, 3, 4, 0, 5, 6]
反向第 1 轮的第 2 次交换：[1, 2, 3, 0, 4, 5, 6]
反向第 1 轮的第 3 次交换：[1, 2, 0, 3, 4, 5, 6]
反向第 1 轮的第 4 次交换：[1, 0, 2, 3, 4, 5, 6]
反向第 1 轮的第 5 次交换：[0, 1, 2, 3, 4, 5, 6]
反向第 1 轮最终结果：[0, 1, 2, 3, 4, 5, 6]
#########################
第 2 轮:
正向第 2 轮的第 1 次交换：[0, 1, 2, 3, 4, 5, 6]
正向第 2 轮的第 2 次交换：[0, 1, 2, 3, 4, 5, 6]
正向第 2 轮的第 3 次交换：[0, 1, 2, 3, 4, 5, 6]
正向第 2 轮的第 4 次交换：[0, 1, 2, 3, 4, 5, 6]
正向第 2 轮最终结果：[0, 1, 2, 3, 4, 5, 6]
#########################
最终排序结果：[0, 1, 2, 3, 4, 5, 6]
