冒泡排序和优化后冒泡排序测试

结论:
1. 10万长度的数组, 基本冒泡耗时12610ms, 优化后的耗时12792ms, 尴尬, 反而增加了时间. 这是因为优化需要增加代码量, 从而增多了指令, 一次程度上提高了复杂度.
2. 但是, 如果10万的本身就是正序的序列, 优化后耗时4ms.

基本冒泡排序:

public static void bubbleSort(int[] arr) {
    int len = arr.length;
    for (int i = len - 1; i > 0; i--) {
        for (int k = 0; k < i; k++) {
            if (arr[k] > arr[k + 1]) {
                int temp = arr[k];
                arr[k] = arr[k + 1];
                arr[k + 1] = temp;
            }
        }
    }
}

优化冒泡排序

增加标记功能, 用来记录是否发生了交换.

    /* 冒泡排序 : 升序 --优化: 增加是否交换的标记 */
//  某趟排序中, 如果没有发生交换, 那么就可以提前结束了
//  *: 经过测试, 数组随机程度较大时, 优化程度不明显
    // int//
public static void bubbleSort2(int[] arr) {
    boolean is_swap = false;
    int len = arr.length;
    for (int i = len - 1; i > 0; i--) {
        for (int k = 0; k < i; k++) {
            if (arr[k] > arr[k + 1]) {
                int temp = arr[k];
                arr[k] = arr[k + 1];
                arr[k + 1] = temp;
                is_swap = true;  //发生了交换  \此处增加了操作, 增加了代码复杂度.
            }

        }
        //没有发生交换表示前面都是正序了, 则返回.
        if (is_swap==false) {
            return;
        }
    }
}

测试代码:

public static void main(String[] args) {
    int[] arr = MyJava.randomArr(100000, 10000, 1234);
    long t0 = System.currentTimeMillis();
    //基本冒泡//
    bubbleSort(arr);  //12610ms 10万 \ 正序时1178ms(由于本身就是升序, 没有了交换的操作, 节约了时间.)
    //优化后冒泡//    
    bubbleSort2(arr); //12792ms 10万 \ 正序时4ms
    long t1 = System.currentTimeMillis();
    System.out.println((t1-t0) + "ms");
}