冒泡排序的优化

1，当冒泡到一定程度时，已经有序之后则不需要再次的冒泡了。

这通过使用标志位进行实现：

for (int i = 0, len = arr.length; i < arr.length; i++) {
            boolean hasChanged = false;
            for (int j = 0; j < len - i - 1; j++) {
                if (arr[j].compareTo(arr[j + 1]) > 0) {
                    swap(arr, j, j + 1);
                    hasChanged = true;
                }
            }
            if(!hasChanged) break;
        }

2，记录上一轮发生交换的最大序号，表明下一轮时便不需要再对后面的进行判断以及交换了

void sort(...){
    int lastEX = length - 1;
    int lastEX = length - 1;
        for(int i = lastEX;i>0;i--){
            i = lastEX;
            for(int j = 0 ; j<i ;j++){
                numofBJ += 1;
                if(n[j]>n[j+1]){
                    int temp = n[j];
                    n[j] = n[j+1];
                    n[j+1] = temp;
                    lastEX = j;

                    numofSwap += 1;
                }
            }
        }
}

下面进行举例：

如： 1 3 5 9 2 6 7 10

第一轮

1. ，lastEX = length - 1 = 7;
2. ，此时 i 从 i = lastEX = 7 循环到i=0 ；
3. ， j 从 j = 0 循环到 length - i - 1 ，
4. ，第一轮 j 的循环走完时，数组变成了 1 3 5 2 6 7 9 10
5. ，此时 lastEX = 6

第二轮，

1. 此时 lastEX = 6, i = 6 ； 注意：此时只是完成了第二层循环的一轮
2. 外层循环为 ： i = 6 到i = 0， 注意，这里要将lastEX的值赋值给 i ，这样才可以起到减少外层循环的次数
3. 内层循环第二轮时，当 5 和 2 交换之后便不再交换，所以此时 lastEX = 2，数组变成了1 3 2 5 6 7 9 0

第三轮

1. 此时 外层循环的i 已经通过lastEX的赋值降成了2，大大减少了外层循环的次数
2. 第三轮，将是 3 与 2 进行交换，lastEX = 1；

3. 数组已经有序

   通过对比

   优化之后的，通过打印 交换次数和 比较次数
   1，本文优化1 交换次数 5 ，比较次数 24
   2，本文优化2 交换次数 5 ， 比较次数 15
   3，常见冒泡 交换次数 5， 比较次数 28