冒泡排序——Bubble Sort

冒泡排序只会操作相邻的两个数据，每次冒泡操作都会对相邻的两个元素进行比较，看是否满足大小关系要求。

冒泡排序是原地、稳定的排序。

原地：冒泡的过程只涉及相邻数据的交换操作，只需要常量级的临时空间，空间复杂度为O(1)。

稳定：在冒泡排序中，只有交换才可以改变两个元素的先后顺序。当有相邻的两个元素大小相等的时候，不做交换，
相同大小的数据在排序前后不后改变顺序。

时间复杂度：最好情况是有序的为O(n)，最坏情况是倒序的为O(n*2),平均情况是加权平均期望，涉及概率论。

考虑边界情况

public class Bubble {
    public static void main(String[] args) {
        int [] arr = {1,2,3,6,4,7,5};
        sort(arr);
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]);
        }
    }

    public static void sort(int[]arr){
//      边界情况
        if(arr.length<=1){
            return;
        }
//      第1次for循环是确定冒泡的次数
        for (int i = 0; i < arr.length; i++) {
//          arr.length-i-1 是因为下面的 arr[j+1]
//          第2次for循环是进行交换
            for (int j = 0; j < arr.length-i-1; j++) {
                if(arr[j]>arr[j+1]){
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
    }
}

优化：添加标志位

public class Bubble {
    public static void main(String[] args) {
        int [] arr = {1,2,3,6,4,7,5};
        sort(arr);
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]);
        }
    }

    public static void sort(int[]arr){
//      边界情况
        if(arr.length<=1){
            return;
        }
//      第1次for循环是确定冒泡的次数
        for (int i = 0; i < arr.length; i++) {
//          提前退出冒泡循环的标志位 
            boolean flag = false;
//          第2次for循环是进行交换
//          arr.length-i-1 是因为 arr[j+1]
            for (int j = 0; j < arr.length-i-1; j++) {
//              交换
                if(arr[j]>arr[j+1]){
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
//          表示有数据交换
            flag = true;
            }
//          没有数据交换，提前退出
            if(!flag){
                break;
            }
        }
    }
}