冒泡排序的优化方案

为什么要突然要讲这个呢，因为之前被朋友问到的，刚开始一脸蒙蔽，写了那某多次冒泡排序，自己也没想太多优化的问题。

所以Google了一下，其实优化的核心思想就是减少比较的次数，非常简单。

普通的冒泡排序如下：

 static void BubbleSort1(int[] arr, int size)
    {
        int i = 0, j = 0;
        int count = 0;
        for (i = 0; i < size - 1; i++)//一共要排序size-1次
        {
            for (j = 0; j < size - 1 - i; j++)//选出该趟排序的最大值往后移动
            {
                if (arr[j] > arr[j + 1])
                {
                    int tmp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = tmp;
                }
                count++;
            }
        }
        //count计算比较的次数
        System.out.println("bubble 1 = "+count);
    }

 冒泡排序的最坏时间复杂度为O(n^2)。

 优化方案1：优化外层循环

//冒泡排序优化1
    static void BubbleSort2(int[] arr, int size)
    {
        int i = 0, j = 0;
        int count = 0;
        for (i = 0; i < size - 1; i++)//一共要排序size-1次
        {
            //每次遍历标志位都要先置为0，才能判断后面的元素是否发生了交换
            int flag = 0;

            for (j = 0; j < size - 1 - i; j++)//选出该趟排序的最大值往后移动
            {
                if (arr[j] > arr[j + 1])
                {
                    int tmp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = tmp;
                    flag = 1;//只要有发生了交换，flag就置为1
                }
                count++;
            }

            //判断标志位是否为0，如果为0，说明后面的元素已经有序，就直接return
            if (flag == 0)
            {
                break;
            }
        }

        System.out.println("bubble 2 = "+count);

    }

 在上面给出的算法中，引入一个标签flag，在每趟排序开始前，先将其置为0。若排序过程中发生了交换，则将其置为1。各趟排   序结束时检查flag，若未曾发生过交换，说明此时的数组已经是有序的了，则终止算法，不再进行多余的相邻比较。

 优化方案2：优化内层循环

 //冒泡排序优化2
    static void BubbleSort3(int[] arr, int size)
    {
        int i = 0, j = 0;
        int k = size - 1,pos = 0;//pos变量用来标记循环里最后一次交换的位置
        int count = 0;

        for (i = 0; i < size - 1; i++)//一共要排序size-1次
        {
            //每次遍历标志位都要先置为0，才能判断后面的元素是否发生了交换
            int flag = 0;
            for (j = 0; j <k; j++)//选出该趟排序的最大值往后移动
            {
                if (arr[j] > arr[j + 1])
                {
                    int tmp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = tmp;
                    flag = 1;//只要有发生了交换，flag就置为1
                    pos = j;//循环里最后一次交换的位置 j赋给pos
                }
                count++;
            }
            k = pos;
            //判断标志位是否为0，如果为0，说明后面的元素已经有序，就直接return
            if (flag == 0)
            {
               break;
            }
        }
        System.out.println("bubble 3 = "+count);
    }

方案2 在 方案1的基础下又进行了一次优化，方案2的算法在每趟扫描中，记住最后一次交换发生的位置lastExchange，（该位置之后的相邻记录均已有序）。下一趟排序开始时，R[1..lastExchange-1]是无序区，R[lastExchange..n]是有序区。这样，一趟排序可能使当前无序区扩充多个记录，因此记住最后一次交换发生的位置lastExchange，从而减少排序的趟数。

总结

算法复杂度比较：方案2 <= 方案1 <= 普通冒泡

参考：https://blog.csdn.net/yanxiaolx/article/details/51622286