java数据结构和算法——冒泡排序算法

目录

    • 一、冒泡排序算法介绍
    • 二、冒泡排序算法思路图解
    • 三、冒泡排序算法的演变过程示例
    • 四、冒泡排序算法的完整示例代码
    • 五、冒泡排序算法的完整示例代码优化
    • 六、测试冒泡排序算法所消耗的时间示例

一、冒泡排序算法介绍

  • 比较相邻的元素。如果第一个比第二个大,就交换他们两个。
  • 对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对。在这一点,最后的元素应该会是最大的数。
  • 针对所有的元素重复以上的步骤,除了最后一个。
  • 持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较。

二、冒泡排序算法思路图解

java数据结构和算法——冒泡排序算法_第1张图片

三、冒泡排序算法的演变过程示例

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函数,结果如下:
java数据结构和算法——冒泡排序算法_第2张图片

四、冒泡排序算法的完整示例代码

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函数,结果如下:
java数据结构和算法——冒泡排序算法_第3张图片

五、冒泡排序算法的完整示例代码优化

如果发现在某趟排序中,没有发生一次交换,可以提前结束冒泡排序

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函数,结果如下:
java数据结构和算法——冒泡排序算法_第4张图片

六、测试冒泡排序算法所消耗的时间示例

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函数,运行结果如下:
java数据结构和算法——冒泡排序算法_第5张图片
java数据结构和算法——冒泡排序算法_第6张图片
本地计算机,win10系统,8G内存测试带有100000个随机数的数组,用冒泡排序耗时大约20秒

你可能感兴趣的:(java数据结构和算法)