冒泡排序 (小优化)

时间复杂度：O(n²)  

空间复杂度：1   

稳定性：稳定

冒泡排序的原理是：从左到右，相邻元素进行比较。每次比较一轮，就会找到序列中最大并且将这个数放到数组的相应位置。
比如对下面这个序列进行从小到大排序：

5, 9, 2, 7, 4, 1, 8, 3, 6

第一轮：
1) 5 和 9比，5 < 9，则它们不交换位置

5, 9, 2, 7, 4, 1, 8, 3, 6

2) 9 和 2 比，9 > 2，则交换位置

5,  2,  9,  7,  4,  1,  8,  3,  6

3）9 和 7 比，9 > 7，则它们互换位置

5,  2,  7,  9,  4,  1,  8,  3,  6

依次类推： 第一轮比较完之后找到了序列中最大的那个数，并被调换到最右边。

5,  2,  7,   4,  1,  8,  3,  6，9

第二轮：
1) 5 和 2 比，5 > 2，则交换位置。

2,  5,  7,   4,  1,  8,  3,  6，9

2) 5和7比较， 5  < 7， 不交换位置

2,  5,  7,   4,  1,  8,  3,  6，9

依次类推：第二轮比较完之后，就找到第二大的数，将第二大的数交换到了数组的倒数第二个位置。

2,  5,  4,  1,  8,  3,  6，7，9

 依次循环：就得到了有序的数组。

package sort;

/**冒泡排序( 小 --> 大)
 * @author codelmh
 * @data 2021/11/18
 */
public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = {5, 9, 2, 7, 4, 1, 8, 3, 6};
        /**
         * 思路:
         * 1.arr[j] 与 arr[j+1] 比较
         * 2.若 arr[j]大于 arr[j+1] 则进行位置交换， 否则不进行交换操作
         * 循环进行操作 1,2 直到数组值循环完之后
         * 第一次循环完，最大的值将会交换到数组的最后
         * 第二次循环完，第二大的值将会交换到数组的倒数的第二个位置
         * 所以得到内循环条件  j < arr.length-1-i
         *
         * 优化思想: 若还没有开始就是有序的 如何判断结束循环 达到冒泡排序的最优时间复杂度O(n)
         * 思路： 判断条件  某一次循环没有一次发生位置改变 则说明数组已经有序
         * 设置一个 flag = false
         * 在位置交换的时候 将 flag = true
         * 在本次循环结束后 判断 flag 是否等于 false
         * 等于 则 没有交换 不等于 则将 flag重置为 flag = true
         */
        boolean flag = false;
        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]) {
                    flag = true;
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
            if (!flag) break;
            flag = false;
        }
        //打印数组
        SortUtils.print(arr);
    }
}