java 排序算法之冒泡排序

 更新时间:2021年09月01日 15:46:16   作者:天然呆dull  
这篇文章主要介绍了java 排序算法之冒泡排序,文中运用大量的代码讲解相关知识,非常详细,感兴趣的小伙伴可以参考一下

基本介绍

冒泡排序(Bubble Sorting)(时间复杂度为 O(n²))的基本思想:通过对待排序序列 从前向后(从下标较小的元素开始),依次比较相邻元素的值,若发现逆序则交换,使值较大的元素逐渐从前移向后部,就像水底下的旗袍一样逐渐向上冒。

优化点:因为排序过程中,个元素不断接近自己的位置,如果一趟比较下来没有进行过交换,就说明序列有序,因此要在排序过程中设置一个标志判断元素是否进行过交换。从而减少不必要的比较。(该优化点可以在完成基本的冒泡排序之后再做)

图解冒泡排序算法的过程

动图:

冒泡排序小结:

1.共进行 数组大小 - 1 次大的循环

2.每一趟排序的次数在逐渐的减少

3.优化:如果发现在某趟排序中,没有发生一次交换,则可以提前结束冒泡排序。

代码实现

演变过程

为了容易理解,先演示冒泡排序的演变过程

    /**
     * 为了更好的理解,这里把冒泡排序的演变过程演示出来
     */
    @Test
    public void processDemo() {
        int arr[] = {3, 9, -1, 10, -2};

        // 第 1 趟排序:将最大的数排在最后
        // 总共排序:arr.length - 1
        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.println("第 1 趟排序后的数组");
        System.out.println(Arrays.toString(arr));

        // 第 2 趟排序:将第 2 大的数排在倒数第 2 位
        // 总共排序:arr.length - 1 - 1  ;
        // 从头开始排序,其他没有变化,只是将排序次数减少了一次
        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.println("第 2 趟排序后的数组");
        System.out.println(Arrays.toString(arr));

        // 第 3 趟排序:将第 3 大的数排在倒数第 3 位
        // 总共排序:arr.length - 1 - 2  ;
        // 从头开始排序,其他没有变化,只是将排序次数减少了 2 次
        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.println("第 3 趟排序后的数组");
        System.out.println(Arrays.toString(arr));

        // 第 4 趟排序:将第 4 大的数排在倒数第 4 位
        // 总共排序:arr.length - 1 - 3  ;
        // 从头开始排序,其他没有变化,只是将排序次数减少了 3 次
        for (int i = 0; i < arr.length - 1 -3; i++) {
            if (arr[i] > arr[i + 1]) {
                temp = arr[i];
                arr[i] = arr[i + 1];
                arr[i + 1] = temp;
            }
        }
        System.out.println("第 4 趟排序后的数组");
        System.out.println(Arrays.toString(arr));

        // 第 5 趟没有必要,因为这里有 5 个数字,确定了 4 个数字,剩下的那一个就已经出来了
    }

测试输出

第 1 趟排序后的数组
[3, -1, 9, -2, 10]
第 2 趟排序后的数组
[-1, 3, -2, 9, 10]
第 3 趟排序后的数组
[-1, -2, 3, 9, 10]
第 4 趟排序后的数组
[-2, -1, 3, 9, 10]

从上述的 4 趟排序过程来看,循环体都是一样的,只是每次循环的次数在减少,那么就可以如下简化

@Test
public void processDemo2() {
  int arr[] = {3, 9, -1, 10, -2};

  // 总共排序:arr.length - 1
  int temp = 0; // 临时变量,交换的时候使用
  for (int j = 0; j < arr.length - 1; j++) {
    for (int i = 0; i < arr.length - 1 - j; i++) {
      if (arr[i] > arr[i + 1]) {
        temp = arr[i];
        arr[i] = arr[i + 1];
        arr[i + 1] = temp;
      }
    }
    System.out.println("第 " + (j + 1) + " 趟排序后的数组");
    System.out.println(Arrays.toString(arr));
  }
}

测试输出

第 1 趟排序后的数组
[3, -1, 9, -2, 10]
第 2 趟排序后的数组
[-1, 3, -2, 9, 10]
第 3 趟排序后的数组
[-1, -2, 3, 9, 10]
第 4 趟排序后的数组
[-2, -1, 3, 9, 10]

优化

对于优化,减少排序次数

    @Test
    public void processDemo3() {
        int arr[] = {3, 9, -1, 10, 20};

        // 总共排序:arr.length - 1
        int temp = 0; // 临时变量,交换的时候使用
        boolean change = false;// 标识变量,表示是否进行过交换
        for (int j = 0; j < arr.length - 1; j++) {
            for (int i = 0; i < arr.length - 1 - j; i++) {
                if (arr[i] > arr[i + 1]) {
                    temp = arr[i];
                    arr[i] = arr[i + 1];
                    arr[i + 1] = temp;
                    change = true;
                }
            }
            if(!change){
                // 如果有 1 轮下来,都没有进行排序,则可以提前退出
                break;
            }else{
                change = false; // 重置 change!!!, 进行下次判断
            }
            System.out.println("第 " + (j + 1) + " 趟排序后的数组");
            System.out.println(Arrays.toString(arr));
        }
    }

测试输出:

第 1 趟排序后的数组
[3, -1, 9, 10, 20]
第 2 趟排序后的数组
[-1, 3, 9, 10, 20]

这里更改了原始数组,因为优化的点,得看你这个数组原来的排序 和 元素组成,算是一种概率问题,并不是在任何情况下都可以被优化

封装算法

    /**
     * 把排序算法封装成一个方法,方便被复用
     *
     * @param arr
     */
    public static void bubbleSort(int[] arr) {
        // 总共排序:arr.length - 1
        int temp = 0; // 临时变量,交换的时候使用
        boolean change = false;
        for (int j = 0; j < arr.length - 1; j++) {
            for (int i = 0; i < arr.length - 1 - j; i++) {
                if (arr[i] > arr[i + 1]) {
                    temp = arr[i];
                    arr[i] = arr[i + 1];
                    arr[i + 1] = temp;
                    change = true;
                }
            }
            if(!change){
                // 如果有 1 轮下来,都没有进行排序,则可以提前退出
                break;
            }else{
                change = false; // 重置 change!!!, 进行下次判断
            }
        }
    }

测试调用

    /**
     * 测试封装后的算法
     */
    @Test
    public void bubbleSortTest() {
        int[] arr = {3, 9, -1, 10, 20};
        System.out.println("排序前:" + Arrays.toString(arr));
        bubbleSort(arr);
        System.out.println("排序后:" + Arrays.toString(arr));
    }
    

测试输出

排序前:[3, 9, -1, 10, 20]
排序后:[-1, 3, 9, 10, 20]

大量数据耗时测试

排序随机生成的 8 万个数据

    /**
     * 大量数据排序时间测试
     */
    @Test
    public void bulkDataSort() {
        int max = 80000;
        int[] arr = new int[max];
        for (int i = 0; i < max; i++) {
            arr[i] = (int) (Math.random() * 80000);
        }

        Instant startTime = Instant.now();
        bubbleSort(arr);
//        System.out.println(Arrays.toString(arr));
        Instant endTime = Instant.now();
        System.out.println("共耗时:" + Duration.between(startTime, endTime).toMillis() + " 毫秒");
    }

测试输出

运行几次,差不多在 13 秒左右
共耗时:14656 毫秒
共耗时:13853 毫秒

到此这篇关于java 排序算法之冒泡排序的文章就介绍到这了,更多相关java 冒泡排序内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家!

相关文章

  • java获取文件编码,jsoup获取html纯文本操作

    java获取文件编码,jsoup获取html纯文本操作

    这篇文章主要介绍了java获取文件编码,jsoup获取html纯文本操作,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
    2020-08-08
  • Java发起http请求的完整步骤记录

    Java发起http请求的完整步骤记录

    这篇文章主要给大家介绍了关于Java发起http请求的相关资料,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
    2021-02-02
  • JAVA | Guava EventBus 使用 发布/订阅模式的步骤

    JAVA | Guava EventBus 使用 发布/订阅模式的步骤

    这篇文章主要介绍了JAVA | Guava EventBus 使用 发布/订阅模式的步骤,帮助大家更好的理解和学习使用Guava EventBus,感兴趣的朋友可以了解下
    2021-03-03
  • MyBatis使用Zookeeper保存数据库的配置可动态刷新的实现代码

    MyBatis使用Zookeeper保存数据库的配置可动态刷新的实现代码

    这篇文章主要介绍了MyBatis使用Zookeeper保存数据库的配置,可动态刷新,本文通过实例代码给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
    2021-08-08
  • Hadoop之NameNode Federation图文详解

    Hadoop之NameNode Federation图文详解

    今天小编就为大家分享一篇关于Hadoop之NameNode Federation图文详解,小编觉得内容挺不错的,现在分享给大家,具有很好的参考价值,需要的朋友一起跟随小编来看看吧
    2019-01-01
  • 如何使用Spring自定义Xml标签

    如何使用Spring自定义Xml标签

    要实现自定义的xml配置,需要有两个默认spring配置文件来支持。一个是spring.schemas,一个是spring.handlers,前者是为了验证你自定义的xml配置文件是否符合你的格式要求,后者是告诉spring该如何来解析你自定义的配置文件。本文将介绍如何使用Spring自定义Xml标签
    2021-06-06
  • springboot与springmvc基础入门讲解

    springboot与springmvc基础入门讲解

    本篇文章主要介绍了详解快速搭建Spring Boot+Spring MVC,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
    2021-07-07
  • Java NumberFormat 类的详解及实例

    Java NumberFormat 类的详解及实例

    这篇文章主要介绍了Java NumberFormat 类的详解及实例的相关资料,数字格式化类按照本地风格习惯进行的数字显示,需要的朋友可以参考下
    2017-08-08
  • eclipse+myeclipse 环境配置方法

    eclipse+myeclipse 环境配置方法

    eclipse+myeclipse配置环境
    2009-07-07
  • Java中数组转List的三种方法与对比分析

    Java中数组转List的三种方法与对比分析

    这篇文章主要给大家介绍了关于Java中数组转List的三种方法与对比分析的相关资料,分别介绍了最常见方式、数组转为List后,支持增删改查的方式以及通过集合工具类Collections.addAll()方法,需要的朋友可以参考下
    2018-07-07

最新评论