java 冒泡排序及优化

1. 冒泡排序算法思路

1. 使用两个循环，外层循环是冒泡趟数，内层趟数是具体的冒泡方式
2. 内层循环的具体冒泡排序的方式就是依次比较相邻两个数字的大小
3. 如果前面的数字大于后面的数字，则交换两个数字，重复前两个步骤，直至循环结束

完整代码实现：

 public static void BubbleSort(int[] array){
        // 最后一趟不用比较
        // 外层循环控制的是冒泡的趟数
        for (int i = 0; i <array.length-1 ; ++i) {
            // 一趟冒泡的方式，将相邻元素进行比较，将最大元素往后放
            //内层循环是具体的冒泡方式
            for (int j = 1; j <array.length-i; ++j) {
                if (array[j-1]>array[j]){
                    swap(array,j-1,j);
                }
            }
        }
    }
    
 public static void swap(int[] array,int left,int right){
        int temp=array[left];
        array[left]=array[right];
        array[right]=temp;
}
 public static void printArray(int[] array) {
        for (int e : array) {
            System.out.print(e + " ");
        }
    }
    
 public static void main(String[] args) {
        int[] array={3,8,9,4,1,5,2,0,6,7};
        BubbleSort(array);
        printArray(array);
    }
}

最后一趟只剩一个元素不用进行比较。
且内层循环 j 的范围要看其实位置 j 的大小，如果 j 从0号开始，那么 j < array.length-i-1。

2. 优化

首先，进行优化的原因是冒泡排序很可能在循环结束前就已经有序，所以我们可以定义一个boolean类型的变量来进行检测，如果它的值未曾改变时，就证明序列有序了。
代码：

public static void BubbleSortOP(int[] array){
        // 检测是否进行数据交换
        boolean isChange=false;
        // 最后一趟不用比较
        // 外层循环控制的是冒泡的趟数
        for (int i = 0; i <array.length-1 ; ++i) {
            // 一趟冒泡的方式，将相邻元素进行比较，将最大元素往后放
            //内层循环是具体的冒泡方式
            isChange=false;
            for (int j = 1; j <array.length-i; ++j) {
                if (array[j-1]>array[j]){
                    swap(array,j-1,j);
                    isChange=true;
                }
            }
            // 检测isChange是否被修改
            if (!isChange){
                return;
            }
        }
    }

时间复杂度：O(n^2) （平均）
空间复杂度：O(1)
稳定性：稳定