一:冒泡排序的基本介绍
冒泡排序(Bubble Sorting)的基本思想是:通过对待
排序序列从前向后(从下标较小的元素开始),依次比较
相邻元素的值,若发现逆序则交换,使值较大
的元素逐渐从前移向后部,就象水底下的气泡一样逐渐
向上冒。
因为排序的过程中,各元素不断接近自己的位置,如果一趟比较下
来没有进行过交换,就说明序列有序,因此要在排序过程中设置一个标志flag判断元素是否进行过交换。从而减少不必要的比较。(这里说的优化,可以在冒泡排序写好后,在进行)
我们举一个具体的案例来说明冒泡法。我们将五个无序的数:3, 9, -1, 10, -2 使用冒泡排序法将其排成一个从小到大的有序数列。
思路分析:
- 第一次排序,3没有9大,所以第一次不动,数组依然为3, 9, -1, 10, -2
- 第二次9和-1比较,这里需要做一次交换所以数组为 3 -1 9 10 -2
- 按这样的规律排第一趟排序后的顺序就是 3 -1 9 -2 10.这样就确定了最大的一个数.
第二趟:相当于前四个数进行排序了 - -1 3 9 -2 10
-->
-1 3 9 -2 10-->
-1 3 -2 9 10
第三趟:相当于前三个数进行排序了 - -1 3 -2 9 10
-->
-1 -2 3 9 10.
第四趟: -2 -1 3 9 10
最终排序完成.
总结:冒泡排序规则
(1) 一共进行(数组大小-1次)大的循环
(2) 每一趟的排序的次数在逐渐减小
(3) 如果说我们发现在某趟排序中,没有发生依次交换,可以提前结束冒泡排序,这个是优化的过程
代码实现:
package com.qiu.sort;
import com.sun.org.apache.bcel.internal.generic.ARRAYLENGTH;
import java.util.Arrays;
public class BubbleSort {
public static void main(String[] args) {
int arr[] = {3,9,-1,10,-2};
//冒泡排序的演变过程
/*
1.第一趟排序就是将最大的数排在最后
*/
int temp =0;
for (int j = 0; j < arr.length-1; j++) {
//如果前面的数比后面的数大,交换
if (arr[j]>arr[j+1]){
temp = arr[j] ;
arr[j] =arr[j+1] ;
arr[j+1] = temp;
}
}
System.out.println("第一趟排序的输出:" + Arrays.toString(arr));
//第二趟排序就是将第二大的数排序到倒数第二位
for (int j = 0; j < arr.length-1-1; j++) {
//如果前面的数比后面的数大,交换
if (arr[j]>arr[j+1]){
temp = arr[j] ;
arr[j] =arr[j+1] ;
arr[j+1] = temp;
}
}
System.out.println("第二趟排序的输出:" + Arrays.toString(arr));
for (int j = 0; j < arr.length-1-2; j++) {
//如果前面的数比后面的数大,交换
if (arr[j]>arr[j+1]){
temp = arr[j] ;
arr[j] =arr[j+1] ;
arr[j+1] = temp;
}
}
System.out.println("第三趟排序的输出:" + Arrays.toString(arr));
for (int j = 0; j < arr.length-1-3; j++) {
//如果前面的数比后面的数大,交换
if (arr[j]>arr[j+1]){
temp = arr[j] ;
arr[j] =arr[j+1] ;
arr[j+1] = temp;
}
}
System.out.println("第四趟排序的输出:" + Arrays.toString(arr));
}
}
代码运行结果演示:
这里可以做一个优化:
public static void main(String[] args) {
int arr[] = {3,9,-1,10,-2};
int temp =0;
//冒泡排序的演变过程
/*
1.第一趟排序就是将最大的数排在最后
*/
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]){
temp = arr[j] ;
arr[j] =arr[j+1] ;
arr[j+1] = temp;
}
}
}
System.out.println("排序的输出:" + Arrays.toString(arr));
这里用了双层for循环进行排序,这里的时间复杂度为O(n^2)
这里可能在第二趟的时候就已经排好序了,但是算法依旧会去执行,所以我们需要对算法做优化
代码优化:
public static void main(String[] args) {
int arr[] = {3,9,-1,10,-2};
int temp =0;
boolean flag = false;//标识变量,表示说如果两个数之间做了交换,那么这个flag会变
//冒泡排序的演变过程
/*
1.第一趟排序就是将最大的数排在最后
*/
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]){
flag =true;
temp = arr[j] ;
arr[j] =arr[j+1] ;
arr[j+1] = temp;
}
}
if (!flag){
//在交换过程中一次交换都没有发生过
break;
}else {
flag =false;//重置flag进行下一次的判断
}
}
System.out.println("排序的输出:" + Arrays.toString(arr));
}
}
判断第一趟,第二趟…是否有交换过,如果没有交换直接退出里面一层的循环.
接着我们来看看冒泡排序处理多数据的时间:
//测试一下冒泡排序的速度,给8w随机数组
int[] arr1 = new int[80000];
for (int i = 0; i < 80000; i++) {
arr1[i] =(int)(Math.random()*80000000);
}
//测试排序时间
Date date = new Date();
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String dateStr = format.format(date);
System.out.println("排序前的时间:"+dateStr);
bubbleSort(arr1);
Date date1 = new Date();
SimpleDateFormat format1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String dateStr1 = format1.format(date1);
System.out.println("排序前的时间:"+dateStr1);
代码运行:
大概是16秒时间.