面试官：可以优化一下冒泡排序嘛？

十大排序算法中，冒泡排序应该算得上是最简单的一种排序方法了。之前只知道最简单的两个for循环做冒泡，其实在for循环的同时，还可以通过一些小细节来实现对算法的优化。首先我们可以通过动图来了解其冒泡原理

通过动图可以清晰的看见冒泡的原理：前后比较，然后移位。下面我们进行实战，对下列数组进行排序

int[] arrs = {5,4,1,2,3,6,9,7};

最常见的冒泡排序

    static int[] BubbleSort1(int[] arr){
        int sum =0;
        for (int i=0;i<arr.length;i++){
            for(int j=0;j<arr.length-i-1;j++){
                if (arr[j]>arr[j+1]){
                    int t = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = t;
                }
                sum++;
            }
        }
        System.out.println(sum);
        return arr;
    }

这里我们通过sum来计算一共比较了多少次

结果如下：
28
[1, 2, 3, 4, 5, 6, 7, 9]

优化1，添加标记

相比第一种方式，我们发现其实经过某些排序后，数组已经变得有序，所以后续的排序是没有必要的，不用再继续下去，这里我们添加flag 作为标记

    static int[] BubbleSort2(int[] arr){
        int sum =0;
        for (int i=0;i<arr.length;i++){
            int flag = 0 ; 
            for(int j=0;j<arr.length-i-1;j++){
                if (arr[j]>arr[j+1]){
                    int t = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = t;
                    flag=1;
                }
                sum++;
            }
            if(flag==0){
                break;
            }
        }
        System.out.println(sum);
        return arr;
    }

得到结果

18
[1, 2, 3, 4, 5, 6, 7, 9]

这个flag的标记是优化第二个for循环

优化3，标记交换位置

标记最后一次交换的位置pos，后边没有交换，必然是有序的，然后下一次排序从第一个比较到上次记录的位置结束即可

    public static int[] BubbleSort3(int[] arr){
        int sum =0;
        int pos = 0;//用来记录最后一次交换的位置
        int k = arr.length - 1;
        for (int i=0;i<arr.length;i++){
            int flag = 0 ;
            pos=0;
            for(int j=0;j<k;j++){  //
                if (arr[j]>arr[j+1]){
                    int t = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = t;
                    flag=1;
                    pos=j;
                }
                sum++;
            }
            if(flag==0){
                break;
            }
            k=pos;
        }
        System.out.println(sum);
        return arr;
    }

结果:

15
[1, 2, 3, 4, 5, 6, 7, 9]

目前来看这个冒泡排序已经优化了很多，但是最优解还有一种，双向排序也就是常说的 “ 双指针排序法” 后面单独出记录一篇