java数据结构和算法——冒泡排序算法
目录
- 一、冒泡排序算法介绍
- 二、冒泡排序算法思路图解
- 三、冒泡排序算法的演变过程示例
- 四、冒泡排序算法的完整示例代码
- 五、冒泡排序算法的完整示例代码优化
- 六、测试冒泡排序算法所消耗的时间示例
一、冒泡排序算法介绍
- 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
- 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
- 针对所有的元素重复以上的步骤，除了最后一个。
- 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
二、冒泡排序算法思路图解
三、冒泡排序算法的演变过程示例
1、代码
package com.rf.springboot01.dataStructure.sort;
import java.util.Arrays;
/**
* @description: 冒泡排序
* @author: xiaozhi
* @create: 2020-08-04 08:45
*/
public class BubblingSort {
public static void main(String[] args) {
int[] arr={3, 9, -1, 10, -2};
System.out.println("排序前的数组=========");
System.out.println(Arrays.toString(arr));
bubbleSortSample(arr);
System.out.println("排序后的数组=========");
System.out.println(Arrays.toString(arr));
}
/**
* @Description: 冒泡排序的演变过程示例
* @Param: []
* @Author: xz
* @return: void
* @Date: 2020/8/4 8:57
*/
public static void bubbleSortSample(int[] arr){
System.out.println("排序过程演示中的数组++++++++++++++++");
int temp=0;//定义一个临时变量
//第一趟排序，就是将第一大的数排在倒数第一位
for(int j=0;j<arr.length-1;j++){//arr.length-1可以看做arr.length-1-0
// 如果前面的数比后面的数大，则交换
if(arr[j]>arr[j+1]){
temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
System.out.println("第一趟排序后的数组");
System.out.println(Arrays.toString(arr));
//第二趟排序，就是将第二大的数排在倒数第二位
for(int j=0;j<arr.length-1-1;j++){//因为每一趟排序的次数都在逐渐递减，所以第二趟排序需要-1
// 如果前面的数比后面的数大，则交换
if(arr[j]>arr[j+1]){
temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
System.out.println("第二趟排序后的数组");
System.out.println(Arrays.toString(arr));
//第三趟排序，就是将第三大的数排在倒数第三位
for(int j=0;j<arr.length-1-2;j++){//因为每一趟排序的次数都在逐渐递减，所以第三趟排序需要-2
// 如果前面的数比后面的数大，则交换
if(arr[j]>arr[j+1]){
temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
System.out.println("第三趟排序后的数组");
System.out.println(Arrays.toString(arr));
//第四趟排序，就是将第四大的数排在倒数第四位
for(int j=0;j<arr.length-1-3;j++){//因为每一趟排序的次数都在逐渐递减，所以第三趟排序需要-3
// 如果前面的数比后面的数大，则交换
if(arr[j]>arr[j+1]){
temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
System.out.println("第四趟排序后的数组");
System.out.println(Arrays.toString(arr));
}
}
2、运行main函数，结果如下：
四、冒泡排序算法的完整示例代码
1、代码
package com.rf.springboot01.dataStructure.sort;
import java.util.Arrays;
/**
* @description: 冒泡排序完整示例
* @author: xiaozhi
* @create: 2020-08-04 08:45
*/
public class BubblingSort {
public static void main(String[] args) {
int[] arr={3, 9, -1, 10, -2};
System.out.println("排序前的数组=========");
System.out.println(Arrays.toString(arr));
bubbleSort(arr);
System.out.println("排序后的数组=========");
System.out.println(Arrays.toString(arr));
}
/**
* @Description: 冒泡排序完整示例方法
* @Param:
* @Author: xz
* @return:
* @Date: 2020/8/4 8:58
*/
public static void bubbleSort(int[] arr){
int temp=0;//定义一个临时变量
//在每一趟排序的for循环外层在嵌套一个for循环
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("完整版代码，第"+(i+1)+"趟排序后的数组");
System.out.println(Arrays.toString(arr));
}
}
}
2、运行main函数，结果如下：
五、冒泡排序算法的完整示例代码优化
如果发现在某趟排序中，没有发生一次交换，可以提前结束冒泡排序
1、代码
package com.rf.springboot01.dataStructure.sort;
import java.util.Arrays;
/**
* @description: 冒泡排序的演变过程示例及冒泡排序整合示例
* @author: xiaozhi
* @create: 2020-08-04 08:45
*/
public class BubblingSort {
public static void main(String[] args) {
int arr[] = {3, 9, -1, 10, 20};
System.out.println("排序前的数组=========");
System.out.println(Arrays.toString(arr));
bubbleSortOptimize(arr);
System.out.println("排序后的数组=========");
System.out.println(Arrays.toString(arr));
}
/**
* @Description: 冒泡排序完整代码优化
* 如果发现在某趟排序中，没有发生一次交换，可以提前结束冒泡排序
* @Param: [arr]
* @Author: xz
* @return: void
* @Date: 2020/8/4 21:33
*/
public static void bubbleSortOptimize(int[] arr){
int temp=0;//定义一个临时变量
//在每一趟排序的for循环外层在嵌套一个for循环
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]){
flag = true;
temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
System.out.println("完整版代码优化，第"+(i+1)+"趟排序后的数组");
System.out.println(Arrays.toString(arr));
if(!flag){//在第一趟排序中，一次都没有交换
break;
}else{//如果有交换，重置flag进行下次判断
flag=false;
}
}
}
}
2、运行main函数，结果如下：
六、测试冒泡排序算法所消耗的时间示例
1、代码：
package com.rf.springboot01.dataStructure.sort;
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;
import static com.rf.springboot01.dataStructure.sort.BubblingSort.bubbleSortOptimize;
/**
* @description: 冒泡排序耗时测试
* @author: xiaozhi
* @create: 2020-08-04 22:15
*/
public class BubblingSort2 {
public static void main(String[] args) {
int arr[] = new int[100000];
for(int i=0;i<100000;i++){//创建一个带有100000个随机数的数组
arr[i]= (int) (Math.random()*8000000); //随机生成（0到8000000之间）的数
}
SimpleDateFormat simpleDateFormat=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date date1=new Date();
String startTime=simpleDateFormat.format(date1);
System.out.println("排序前的时间========="+startTime);
bubbleSortOptimize(arr);
Date date2=new Date();
String endTime=simpleDateFormat.format(date2);
System.out.println("排序后的时间========="+endTime);
}
/**
* @Description: 冒泡排序完整代码优化
* 如果发现在某趟排序中，没有发生一次交换，可以提前结束冒泡排序
* @Param: [arr]
* @Author: xz
* @return: void
* @Date: 2020/8/4 21:33
*/
public static void bubbleSortOptimize(int[] arr){
int temp=0;//定义一个临时变量
//在每一趟排序的for循环外层在嵌套一个for循环
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]){
flag = true;
temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
if(!flag){//在第一趟排序中，一次都没有交换
break;
}else{//如果有交换，重置flag进行下次判断
flag=false;
}
}
}
}
2、运行main函数，运行结果如下：
本地计算机，win10系统，8G内存测试带有100000个随机数的数组，用冒泡排序耗时大约20秒