Java 实现冒泡排序

一、原理

每次比较两个相邻的元素，将较大的元素交互到后端

二、具体流程

1. 比较相邻的两个元素，如果第一个比第二个大就交换位置
2. 对每个相邻的元素进行比较，从开始第一个元素到结尾的最后一个元素，每轮循环比较之后，最后的是最大的元素
3. 每一次这样的循环之后都会有一个最大的数在后面，每确定一个最大的数，那个数在最后面就不需要比较它这是内循环
4. 每次循环确定最大数移到最后，每次外循环的次数减一次（外循环）

三、图解排序过程

1. 一次冒泡的图解过程流程如下图

   第一次冒泡

   图中可以看出经过一次冒泡之后，a[4] 这个个元素变成最大的数字 7，经过 N 次这样的操作之后，那么数组中所有的元素像气泡一样漂浮到相应的位置

2. 经过 N 次这样操作之后的冒泡之后结果如下

   冒泡结果

四、代码示例

public class BubbleSort {

    public static void bubbleSort(int[] args) {
        int length = args.length;
        int[] bubbleSort = new int[length];
        if (length <= 1) {
            return;
        }

        for (int i = 0; i < length; i++) {
            StringBuilder sb = new StringBuilder();
            for (int j = 0; j < length - 1 - i; j++) {
                if (args[j] > args[j + 1]) {
                    int temp = args[j];
                    args[j] = args[j + 1];
                    args[j + 1] = temp;
                }
            }
            sb.append("第-" + i + "-次：");
            for (int arg : args) {
                sb.append(arg + "；");
            }
            System.out.println(sb.toString());
        }
    }

    public static void main(String[] args) {
        int[] args1 = new int[]{7, 2, 1, 3, 2};
        bubbleSort(args1);
        for (int i : args1) {
            System.out.print(i + ",");
        }
    }
}

1. 运行结果：

image-20201028203257582

2. 从上面的运行结果可以看出，经过两次的冒泡之后，其实这个排序已经完成，但是还是执行了比较的操作，于是考虑代码逻辑上是否有优化的空间，优化如下：

   public class BubbleSort {
   
       public static void bubbleSort(int[] args) {
           int length = args.length;
           int[] bubbleSort = new int[length];
           if (length <= 1) {
               return;
           }
   
           for (int i = 0; i < length; i++) {
               StringBuilder sb = new StringBuilder();
               //优化后
               // 提前退出冒泡循环的标志位,即一次比较中没有交换任何元素，这个数组就已经是有序的了
               boolean bubbleChange = false;
               for (int j = 0; j < length - 1 - i; j++) {
                   if (args[j] > args[j + 1]) {
                       int temp = args[j];
                       args[j] = args[j + 1];
                       args[j + 1] = temp;
                       bubbleChange = true;
                   }
               }
               //优化后
               if (!bubbleChange) break;
               sb.append("第-" + i + "-次：");
               for (int arg : args) {
                   sb.append(arg + "；");
               }
               System.out.println(sb.toString());
           }
       }
   
       public static void main(String[] args) {
           int[] args1 = new int[]{7, 2, 1, 3, 2};
           bubbleSort(args1);
           for (int i : args1) {
               System.out.print(i + ",");
           }
       }
   }
   

   运行结果:

   image-20201028203737513

五、时间复杂度

冒泡排序总的平均时间复杂度为：O(n2)