冒泡排序（JAVA）

java基础——冒泡排序

---

一、冒泡排序原理

原理：（从小到大排序）依次比较相邻元素值大小，如果arr[i] > arr[i+1]，将两个元素交换位置，直到没有相邻元素需要交换，也就是说该元素列已经排序完成。

二、基础实现

public static void bubble_v1(int[] arr) {
        for (int i = 0; i < a.length-1; i++) {
            for (int j = 0; j < arr.length-1-i; j++) {
                System.out.println("比较的次数：" + j);
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j+1];
                    arr[j+1] = arr[j];
                    arr[j] = temp;
                }
            }
            System.out.println("第"+(i+1)+"轮排序结果" + Arrays.toString(arr));
        }
    }

private static int[] a = {6,4,5,3,2,1,7,8,9};
    public static void main(String[] args) {
        bubble_v1(a);
        // bubble_v2(a);
        //bubble_v3(a);
    }

代码运行结果：

比较的次数：0
比较的次数：1
比较的次数：2
比较的次数：3
比较的次数：4
比较的次数：5
比较的次数：6
比较的次数：7
第1轮排序结果[4, 5, 3, 2, 1, 6, 7, 8, 9]
比较的次数：0
比较的次数：1
比较的次数：2
比较的次数：3
比较的次数：4
比较的次数：5
比较的次数：6
第2轮排序结果[4, 3, 2, 1, 5, 6, 7, 8, 9]
比较的次数：0
比较的次数：1
比较的次数：2
比较的次数：3
比较的次数：4
比较的次数：5
第3轮排序结果[3, 2, 1, 4, 5, 6, 7, 8, 9]
比较的次数：0
比较的次数：1
比较的次数：2
比较的次数：3
比较的次数：4
第4轮排序结果[2, 1, 3, 4, 5, 6, 7, 8, 9]
比较的次数：0
比较的次数：1
比较的次数：2
比较的次数：3
第5轮排序结果[1, 2, 3, 4, 5, 6, 7, 8, 9]
比较的次数：0
比较的次数：1
比较的次数：2
第6轮排序结果[1, 2, 3, 4, 5, 6, 7, 8, 9]
比较的次数：0
比较的次数：1
第7轮排序结果[1, 2, 3, 4, 5, 6, 7, 8, 9]
比较的次数：0
第8轮排序结果[1, 2, 3, 4, 5, 6, 7, 8, 9]

  外层循环表示最多需要比较多少轮，长度为length的数组，最多比较length-1次即可实现有序。内层for 循环实现两个元素的两两比较,如果前边的元素大于后边的元素则进行位置交换，比较的次数为arr.length-1-i。

三、优化1

问题：通过观察打印结果很容易观察到当执行完第五轮冒泡，数组已经有序，后边又多执行3次
优化思路：每轮冒泡结束后判断是是否执行了交换代码，如果没有执行交换说明数组已经有序

/**
     * 通过判断比较次数，如果比较次数为0 冒泡结束
     * @param arr
     */
    public static void bubble_v2(int[] arr) {
        for (int i = 0; i < a.length; i++) {
            boolean change = false;
            for (int j = 0; j < arr.length-i-1; j++) {
                System.out.println("比较的次数：" + j);
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j+1];
                    arr[j+1] = arr[j];
                    arr[j] = temp;
                    change = true;
                }
            }
            System.out.println("第"+(i+1)+"轮排序结果" + Arrays.toString(arr));
            // 如果没有进行交换 冒泡结束
            if (!change) {
                break;
            }
        }
    }

执行打印结果，冒泡次数减少

比较的次数：0
比较的次数：1
比较的次数：2
比较的次数：3
比较的次数：4
比较的次数：5
比较的次数：6
比较的次数：7
第1轮排序结果[4, 5, 3, 2, 1, 6, 7, 8, 9]
比较的次数：0
比较的次数：1
比较的次数：2
比较的次数：3
比较的次数：4
比较的次数：5
比较的次数：6
第2轮排序结果[4, 3, 2, 1, 5, 6, 7, 8, 9]
比较的次数：0
比较的次数：1
比较的次数：2
比较的次数：3
比较的次数：4
比较的次数：5
第3轮排序结果[3, 2, 1, 4, 5, 6, 7, 8, 9]
比较的次数：0
比较的次数：1
比较的次数：2
比较的次数：3
比较的次数：4
第4轮排序结果[2, 1, 3, 4, 5, 6, 7, 8, 9]
比较的次数：0
比较的次数：1
比较的次数：2
比较的次数：3
第5轮排序结果[1, 2, 3, 4, 5, 6, 7, 8, 9]
比较的次数：0
比较的次数：1
比较的次数：2
第6轮排序结果[1, 2, 3, 4, 5, 6, 7, 8, 9]

四、最终优化

问题：数组第一次冒泡后最后三位 {…,7,8,9}已经有序，但是第二次冒泡的时候还要比对
解决：记录最后一次交换位置的索引，作为下次比对的循环次数，避免重复比对

public static void bubble_v3(int[] arr) {
        // 比较的次数
        int x = arr.length -1;
       while (true){
            int last = 0;
            for (int j = 0; j < x; j++) {
                System.out.println("比较的次数：" + j);
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j+1];
                    arr[j+1] = arr[j];
                    arr[j] = temp;
                    // 记录最后一次交换的索引
                    last = j;
                }
            }
            // 最后一次交换的索引作为下次冒泡的循环次数
            x = last;
            System.out.println("第轮排序结果" + Arrays.toString(arr));
            // 如果下次循环交换次数是0 结束
            if (x == 0) {
                break;
            }
        }
    }

打印结果：

比较的次数：0
比较的次数：1
比较的次数：2
比较的次数：3
比较的次数：4
比较的次数：5
比较的次数：6
比较的次数：7
第轮排序结果[4, 5, 3, 2, 1, 6, 7, 8, 9]
比较的次数：0
比较的次数：1
比较的次数：2
比较的次数：3
第轮排序结果[4, 3, 2, 1, 5, 6, 7, 8, 9]
比较的次数：0
比较的次数：1
比较的次数：2
第轮排序结果[3, 2, 1, 4, 5, 6, 7, 8, 9]
比较的次数：0
比较的次数：1
第轮排序结果[2, 1, 3, 4, 5, 6, 7, 8, 9]
比较的次数：0
第轮排序结果[1, 2, 3, 4, 5, 6, 7, 8, 9]
Process finished with exit code 0

总结

积土成山，风雨兴焉；积水成渊，蛟龙生焉；积善成德，而神明自得，圣心备焉。故不积跬步，无以至千里；不积小流，无以成江海。