脚本之家 服务器常用软件
快捷导航
您的位置：首页 → 软件编程 → java → Java冒泡排序的原理及优化

Java排序算法之冒泡排序的原理及优化

 更新时间：2023年11月14日 10:26:35   作者：Cyuujie  
这篇文章主要介绍了Java排序算法之冒泡排序的原理及优化,冒泡排序的思想很简单,遍历数组,比较相邻的两个元素,顺序错误就把它们交换,直到整个数组排序完成,因为每经过一趟排序,越小的元素会经交换而慢慢“浮”到数列的顶端,因此叫做冒泡排序,需要的朋友可以参考下

冒泡排序原理

冒泡排序的思想很简单：遍历数组，比较相邻的两个元素，顺序错误就把它们交换，直到整个数组排序完成。因为每经过一趟排序，越小的元素会经交换而慢慢“浮”到数列的顶端，因此叫做冒泡排序。

在这里插入图片描述

假设我们现在要对数组：arr= {3，9，-1，10，-2，5，21} 进行排序，结合上面的动图，经过第一趟排序后最大的元素会被排到最后。

第一趟排序

public int[] OneStepBubbleSort(int arr[]){
    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.print("第1趟排序完成:");
    System.out.println(Arrays.toString(arr));
    return arr;
}

测试：

public static void main(String[] args) {
    int[] arr = {3, 9, -1, 10, -2, 5, 21};
    SortTest sortTest = new SortTest();
    sortTest.OneStepBubbleSort(arr);
}

结果：

在这里插入图片描述

那么第二趟排序后第二大的元素10会被排到倒数第二的位置。

第二趟排序

public int[] TwoStepBubbleSort(int arr[]){
    int temp = 0;
    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.print("第2趟排序完成:");
    System.out.println(Arrays.toString(arr));
    return arr;
}

测试：

public static void main(String[] args) {
    int[] arr = {3, 9, -1, 10, -2, 5, 21};
    SortTest sortTest = new SortTest();
    sortTest.OneStepBubbleSort(arr);
    sortTest.TwoStepBubbleSort(arr);
}

结果：

在这里插入图片描述

第三趟排序

public int[] ThreeStepBubbleSort(int arr[]){
    int temp = 0;
    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.print("第3趟排序完成:");
    System.out.println(Arrays.toString(arr));
    return arr;
}

测试：

public static void main(String[] args) {
    int[] arr = {3, 9, -1, 10, -2, 5, 21};
    SortTest sortTest = new SortTest();
    sortTest.OneStepBubbleSort(arr);
    sortTest.TwoStepBubbleSort(arr);
		sortTest.ThreeStepBubbleSort(arr);
}

结果：

在这里插入图片描述

如此类推，每一趟排序中不同的地方在于循环的终止条件：arr.length - 1 和 arr.length - 1 - 1 和 arr.length - 1 - 2 等等，那么只需要在此循环外面再包一层循环即可。最终代码为：

冒泡排序算法代码

public int[] BubbleSort(int arr[]){
    int temp = 0;
    for (int i = 0; i < arr.length - 1; i++) {
        for (int j = 0; j < arr.length - i - 1 ; j++) {
            if (arr[j] > arr[j + 1]){
                temp = arr[j];
                arr[j] =  arr[j + 1];
                arr[j + 1] = temp;
            }
        }
        System.out.print("第" + (i + 1) + "趟排序完成:");
        System.out.println(Arrays.toString(arr));
    }
    return arr;
}

测试：

public static void main(String[] args) {
        int[] arr = {3, 9, -1, 10, -2, 5, 21};
        SortTest sortTest = new SortTest();
        System.out.println();
        sortTest.BubbleSort(arr);
    }

结果：

在这里插入图片描述

改进冒泡排序

从上面冒泡排序的结果可以看出，总共进行了6趟排序，但从第4躺开始数组就已经排序完毕了，后面的两趟排序相当于在做无用的比较。

为了解决此问题，我们可以进行优化，思想是：如果发现在某一趟排序中没有发生过一次交换，那么可以提前结束冒泡排序。实现方法是设置一个flag变量来记录是否发生过交换：

public int[] BubbleSort(int arr[]){
    int temp = 0;
    boolean flag = false;
    for (int i = 0; i < arr.length - 1; i++) {
        for (int j = 0; j < arr.length - i - 1 ; j++) {
            if (arr[j] > arr[j + 1]){
                flag = true;
                temp = arr[j];
                arr[j] =  arr[j + 1];
                arr[j + 1] = temp;
            }
        }
        // 判断flag
        if (!flag){
        // 如果flag是false，则退出
            break;
        }else {
        // flag为true，说明发生过交换，那么在进行下一趟前需要把flag重新置为false
            flag = false;
        }
        System.out.print("第" + (i + 1) + "趟排序完成:");
        System.out.println(Arrays.toString(arr));
    }
    return arr;
}

测试：

public static void main(String[] args) {
        int[] arr = {3, 9, -1, 10, -2, 5, 21};
        SortTest sortTest = new SortTest();
        System.out.println();
        sortTest.BubbleSort(arr);
    }

结果：

在这里插入图片描述

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

您可能感兴趣的文章:

相关文章

  • Java数组与字符串深入探索使用方法

    Java数组与字符串深入探索使用方法

    在今天的文章中，我将为你详细讲述Java学习中重要的一节 [ 数组与字符串 ] ，带你深入了解Java语言中数组的声明、创建和初始化方法，字符串的定义以及常用到的操作方法
    2022-07-07
  • Mybatis中mapper.xml实现热加载介绍

    Mybatis中mapper.xml实现热加载介绍

    大家好，本篇文章主要讲的是Mybatis中mapper.xml实现热加载介绍，感兴趣的同学赶快来看一看吧，对你有帮助的话记得收藏一下
    2022-01-01
  • Java超详细透彻讲解接口

    Java超详细透彻讲解接口

    接口是Java中最重要的概念之一，它可以被理解为一种特殊的类，不同的是接口的成员没有执行体，是由全局常量和公共的抽象方法所组成，本文给大家介绍Java接口，感兴趣的朋友一起看看吧
    2022-05-05
  • Java中的Vector和ArrayList区别及比较

    Java中的Vector和ArrayList区别及比较

    这篇文章主要介绍了Java中的Vector和ArrayList区别及比较,本文从API、同步、数据增长、使用模式4个方面总结了它们之间的不同之处,需要的朋友可以参考下
    2015-03-03
  • java类Circle定义计算圆的面积和周长代码示例

    java类Circle定义计算圆的面积和周长代码示例

    要用Java计算圆的周长和面积,需要使用圆的半径和一些数学公式,下面这篇文章主要给大家介绍了关于java类Circle定义计算圆的面积、周长的相关资料,需要的朋友可以参考下
    2024-04-04
  • linux系统下java项目在后台启动的4种方式总结

    linux系统下java项目在后台启动的4种方式总结

    Linux是集多种功能于一身的操作系统,它可以让用户查看和管理当下正在运行的进程,包括Java程序,这篇文章主要给大家总结介绍了关于linux系统下java项目在后台启动的4种方式,需要的朋友可以参考下
    2023-10-10
  • 解析ConcurrentHashMap: transfer方法源码分析(难点)

    解析ConcurrentHashMap: transfer方法源码分析(难点)

    ConcurrentHashMap是由Segment数组结构和HashEntry数组结构组成。Segment的结构和HashMap类似，是一种数组和链表结构，今天给大家普及java面试常见问题---ConcurrentHashMap知识，一起看看吧
    2021-06-06
  • 解决java调用dll报Unable to load library错误的问题

    解决java调用dll报Unable to load library错误的问题

    这篇文章主要介绍了解决java调用dll报Unable to load library错误的问题。具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
    2020-11-11
  • java单例模式4种使用方式分享

    java单例模式4种使用方式分享

    到底如何写一个在生产环境中使用的单实例模式？下面是4种方式，大家参考使用吧
    2014-02-02
  • JAVA后台转换成树结构数据返回给前端的实现方法

    JAVA后台转换成树结构数据返回给前端的实现方法

    这篇文章主要介绍了JAVA后台转换成树结构数据返回给前端的实现方法，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
    2020-03-03

最新评论