冒泡排序（带优化后方案）

冒泡排序

什么是冒泡排序？

冒泡排序的英文Bubble Sort，是一种最基础的交换排序。之所以叫做冒泡排序，因为每一个元素都可以像小气泡一样，根据自身大小一点一点向数组的一侧移动。

案例演示

解释： 如上图从左至右依次把相邻的两个数进行比较，我们最终的目的是实现从左到右是从小到大的排序，所以我们发现相邻两个数前者比后者大就进行交换位置，如果前者不比后者大就不需要交换位置，这样一趟比较下来我们把最大的数移动到了最右端，然后开始第二趟，第二趟我们只需要比较到数组长度减1的位置即可，因为最右边的就是最大的，第三趟比较到长度-2的位置，就这样直到有序。

时间复杂度

如上图，8个数据按照冒泡排序一共比较了7+6+5+4+3+2+1次，根据这个规律我们推导到n个数呢？
那就是(n-1) * (n-2) * (n-3) * … * (3) * (2) * (1)=n*(n-1)/2=n²/2-n/2
所以冒泡排序的复杂度就是O(n²)。

代码实现

public static void main(String[] args) {
        int arr[] = {5,6,3,1,8,7,2,4};
//        int arr[] = {1,3,5,7,9,11,17,13,19,21,23,25,27,29};
        System.out.println("排序前的数组："+  Arrays.toString(arr));
        int result = 0;//记录排序趟数
        int temp = 0;//交换中间变量
        //冒泡排序
        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;
                }
            }
            result++;
        }
        System.out.println("排序后的数组："+Arrays.toString(arr));
        System.out.println("排序趟数："+result);
    }

我们创建一个数组， int arr[] = {5,6,3,1,8,7,2,4};然后定义一个用于交换的中间变量temp，一共需要的趟数为数组长度-1，所以第一层循环为for (int i = 0; i < arr.length - 1; i++)，由于每趟比较之后比较次数都少一，所以第二层循环为 for (int j = 0; j < arr.length - 1 - i; j++) ，然后我们比较如果arr[j] > arr[j + 1]我们就进行交换，然后最后我们就得到了正确结果。

排序前的数组：[5, 6, 3, 1, 8, 7, 2, 4]
排序后的数组：[1, 2, 3, 4, 5, 6, 7, 8]
排序趟数：7

提出问题

假如我们现在有一个有序的数组排序的话，不依旧需要比较这么多次吗，效率是不是很低，有人会说了。有序的我排什么序啊，那我们现在有一个基本有序的数组{1，2，3，4，6，5，7，8}，我们看到了，只有6和5的位置需要交换，我们只需要排序一趟，数组就有序了，可是他依旧会执行七趟。

排序前的数组：[1, 2, 3, 4, 6, 5, 7, 8]
排序后的数组：[1, 2, 3, 4, 5, 6, 7, 8]
排序趟数：7

怎么优化这个问题呢？

解决问题

我们发现，当一趟下来没有发生交换的时候是不是数组就是有序的，所以我们定义一个boolean值，默认给false，如果这一趟发生交换了，把他的值设置为true，同时在第二趟开始之前把他再次设置为false，我们在一趟比较下来进行判断这个boolean值，如果这个值是false的话，证明这一趟没有进行交换，数组已经有序，我们直接break，如果为true，证明发生交换，我们把boolean值设置为false，为下一趟做准备。

优化后代码实现

    public static void main(String[] args) {
        int arr[] = {1,2,3,4,6,5,7,8};
//        int arr[] = {1,3,5,7,9,11,17,13,19,21,23,25,27,29};
        System.out.println("排序前的数组："+  Arrays.toString(arr));
        boolean flag = false;
        int result = 0;//记录排序趟数
        int temp = 0;//交换中间变量
        //冒泡排序
        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;
                    flag = true;
                }
            }
            //当一趟下来没有发生交换的时候证明有序,flag = false 就是没交换
            if (!flag){
                break;
            }else{//有可能第一趟之后就有序了，第一趟变成true，我们还得把他设置成false，为下一趟是否交换做准备
                flag = false;
            }
            result++;
        }
        System.out.println("排序后的数组："+Arrays.toString(arr));
        System.out.println("排序趟数："+result);
    }

结果：

排序前的数组：[1, 2, 3, 4, 6, 5, 7, 8]
排序后的数组：[1, 2, 3, 4, 5, 6, 7, 8]
排序趟数：1

程序源码：

import java.util.Arrays;

public class BubbleSort {
    public static void main(String[] args) {
        int arr[] = {1,2,3,4,6,5,7,8};
//        int arr[] = {1,3,5,7,9,11,17,13,19,21,23,25,27,29};
        System.out.println("排序前的数组："+  Arrays.toString(arr));
        boolean flag = false;
        int result = 0;//记录排序趟数
        int temp = 0;//交换中间变量
        //冒泡排序
        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;
                    flag = true;
                }
            }
            //当一趟下来没有发生交换的时候证明有序,flag = false 就是没交换
            if (!flag){
                break;
            }else{//有可能第一趟之后就有序了，第一趟变成true，我们还得把他设置成false，为下一趟是否交换做准备
                flag = false;
            }
            result++;
        }
        System.out.println("排序后的数组："+Arrays.toString(arr));
        System.out.println("排序趟数："+result);
    }
}