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));
}
}
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));
}
}
}
如果发现在某趟排序中,没有发生一次交换,可以提前结束冒泡排序
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;
}
}
}
}
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秒