Java排序算法之冒泡排序的原理及优化
作者：Cyuujie
这篇文章主要介绍了Java排序算法之冒泡排序的原理及优化,冒泡排序的思想很简单,遍历数组,比较相邻的两个元素,顺序错误就把它们交换,直到整个数组排序完成,因为每经过一趟排序,越小的元素会经交换而慢慢“浮”到数列的顶端,因此叫做冒泡排序,需要的朋友可以参考下
冒泡排序原理
冒泡排序的思想很简单：遍历数组，比较相邻的两个元素，顺序错误就把它们交换，直到整个数组排序完成。因为每经过一趟排序，越小的元素会经交换而慢慢“浮”到数列的顶端，因此叫做冒泡排序。
假设我们现在要对数组：arr= {3，9，-1，10，-2，5，21} 进行排序，结合上面的动图，经过第一趟排序后最大的元素会被排到最后。
第一趟排序
public int[] OneStepBubbleSort(int arr[]){
int temp = 0;
for (int i = 0; i < arr.length - 1; i++){
if (arr[i] > arr[i + 1]){
temp = arr[i];
arr[i] = arr[i + 1];
arr[i + 1] = temp;
}
}
System.out.print("第1趟排序完成:");
System.out.println(Arrays.toString(arr));
return arr;
}测试：
public static void main(String[] args) {
int[] arr = {3, 9, -1, 10, -2, 5, 21};
SortTest sortTest = new SortTest();
sortTest.OneStepBubbleSort(arr);
}
结果：
那么第二趟排序后第二大的元素10会被排到倒数第二的位置。
第二趟排序
public int[] TwoStepBubbleSort(int arr[]){
int temp = 0;
for (int i = 0; i < arr.length - 1 - 1; i++){
if (arr[i] > arr[i + 1]){
temp = arr[i];
arr[i] = arr[i + 1];
arr[i + 1] = temp;
}
}
System.out.print("第2趟排序完成:");
System.out.println(Arrays.toString(arr));
return arr;
}
测试：
public static void main(String[] args) {
int[] arr = {3, 9, -1, 10, -2, 5, 21};
SortTest sortTest = new SortTest();
sortTest.OneStepBubbleSort(arr);
sortTest.TwoStepBubbleSort(arr);
}
结果：
第三趟排序
public int[] ThreeStepBubbleSort(int arr[]){
int temp = 0;
for (int i = 0; i < arr.length - 1 - 2; i++){
if (arr[i] > arr[i + 1]){
temp = arr[i];
arr[i] = arr[i + 1];
arr[i + 1] = temp;
}
}
System.out.print("第3趟排序完成:");
System.out.println(Arrays.toString(arr));
return arr;
}
测试：
public static void main(String[] args) {
int[] arr = {3, 9, -1, 10, -2, 5, 21};
SortTest sortTest = new SortTest();
sortTest.OneStepBubbleSort(arr);
sortTest.TwoStepBubbleSort(arr);
sortTest.ThreeStepBubbleSort(arr);
}
结果：
如此类推，每一趟排序中不同的地方在于循环的终止条件：arr.length - 1 和 arr.length - 1 - 1 和 arr.length - 1 - 2 等等，那么只需要在此循环外面再包一层循环即可。最终代码为：
冒泡排序算法代码
public int[] BubbleSort(int arr[]){
int temp = 0;
for (int i = 0; i < arr.length - 1; i++) {
for (int j = 0; j < arr.length - i - 1 ; j++) {
if (arr[j] > arr[j + 1]){
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
System.out.print("第" + (i + 1) + "趟排序完成:");
System.out.println(Arrays.toString(arr));
}
return arr;
}
测试：
public static void main(String[] args) {
int[] arr = {3, 9, -1, 10, -2, 5, 21};
SortTest sortTest = new SortTest();
System.out.println();
sortTest.BubbleSort(arr);
}
结果：
改进冒泡排序
从上面冒泡排序的结果可以看出，总共进行了6趟排序，但从第4躺开始数组就已经排序完毕了，后面的两趟排序相当于在做无用的比较。
为了解决此问题，我们可以进行优化，思想是：如果发现在某一趟排序中没有发生过一次交换，那么可以提前结束冒泡排序。实现方法是设置一个flag变量来记录是否发生过交换：
public int[] BubbleSort(int arr[]){
int temp = 0;
boolean flag = false;
for (int i = 0; i < arr.length - 1; i++) {
for (int j = 0; j < arr.length - i - 1 ; j++) {
if (arr[j] > arr[j + 1]){
flag = true;
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
// 判断flag
if (!flag){
// 如果flag是false，则退出
break;
}else {
// flag为true，说明发生过交换，那么在进行下一趟前需要把flag重新置为false
flag = false;
}
System.out.print("第" + (i + 1) + "趟排序完成:");
System.out.println(Arrays.toString(arr));
}
return arr;
}
测试：
public static void main(String[] args) {
int[] arr = {3, 9, -1, 10, -2, 5, 21};
SortTest sortTest = new SortTest();
System.out.println();
sortTest.BubbleSort(arr);
}
结果：
到此这篇关于Java排序算法之冒泡排序的原理及优化的文章就介绍到这了,更多相关Java冒泡排序的原理及优化内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！