彻底弄懂冒泡排序

冒泡排序

冒泡排序属于交换排序的一种排序的算法，除此之外，快速排序也属于交换排序。冒泡排序是一种稳定的排序算法。

1 原理

比较相邻的两个元素，将值大的元素交换到右边。

即第一趟先比较第1个和第2个数，大数在后，小数在前，再比较第2个数与第3个数，大数在后，小数在前，以此类推则将最大的数"滚动"到最后一个位置；

以下面5个无序的数据为例：
40 8 15 18 12
第一趟排序：
	第一次比较： 40 和 8比较： 8 40 15 18 12
	第二次比较： 40 和 15比较：8 15 40 18 12
	第三次比较： 40 和 18比较：8 15 18 40 12
	第三次比较： 40 和 12比较：8 15 18 12 40
第一趟排序结束，我们找到了所有数据中的最大值 40。
第二趟排序：
	第一次比较： 8 和 15 比较： 8 15 18 12 40
	第二次比较： 15 和 18 比较：8 15 18 12 40
	第三次比较： 18 和 12 比较：8 15 12 18 40
	第四次比较： 18 和 40 比较：8 15 12 18 40
第二趟排序结束，我们找到了所有数据中的最次大值18。

第三趟排序：
    第一次比较： 8 和 15 比较： 8 15 12 18 40
    第二次比较： 15 和 12 比较：8 12 15 18 40
    第三次比较： 15 和 18 比较：8 12 15 18 40
    第四次比较： 18 和 40 比较：8 12 15 18 40
第三趟排序结束，我们找到了所有数据中的在次大值15。
第四趟排序：
    第一次比较： 8 和 12 比较： 8 12 15 18 40
    第二次比较： 12 和 15 比较：8 12 15 18 40
    第三次比较： 15 和 18 比较：8 12 15 18 40
    第四次比较： 18 和 40 比较：8 12 15 18 40
第四趟排序结束，我们找到了所有数据中的在次大值12。

当进行第五轮冒泡排序时，由于待排序序列中仅剩 1 个元素，无论再进行相邻元素的比较，因此直接将其并入已排序序列中，此时的序列就认定为已排序好的序列（如图 5 所示）。

5个数据经过四次排序之后，我们就成功对这组数据排序完毕了。

2. 算法分析

平均时间复杂度：O(n2)

空间复杂度：O(1) (用于交换)

稳定性：稳定

3 算法实现

（Java为例）

public class BubbleSort {

    public static void main(String[] args) {
        /**
         * 每一轮排序之后，都会把未排序数组中最大值放在数组的右边，
         *
         */
        int[] arr = {3,9,-1,10,5};
        int len = arr.length;
        int temp;
        //N个数字进行排序，要进行n-1趟排序
        for(int i = 0; i < len - 1;i++)
        {
            //  -i的原因： 当执行一轮后，就找到了一个最大值，下次排序时，就不需要对他进行排序了
            for(int j = 0; j < len - i - 1;j++)
            {
                if(arr[j] > arr[j+1])
                {
                    temp = arr[j+1];
                    arr[j+1] = arr[j];
                    arr[j] = temp;
                }
            }
        }
       System.out.println(Arrays.toString(arr));

    }
}

两层for循环的原因都在代码注释中写下了。就不再过多的说了。

通过上述的例子，我们看到，在第四趟排序的过程中，并没有发生数据的交换，也就是说，在第三趟排序结束后，这组数据就成为了一个有序数组。第四趟的排序无疑时多余的了。所以我们需要对代码进行优化调整。

下面是经过优化的代码。

我们设置了一个标志位flag 默认为false，如果发生了交换，那么就将flag置为true，在第二层for循环结束后，判断flag的值，如果为true，就break跳出循环。

public class BubbleSort {

    public static void main(String[] args) {
        /**
         * 每一轮排序之后，都会把未排序数组中最大值放在数组的右边，
         *
         */
        int[] arr = {3,9,-1,10,5};
        int len = arr.length;
        int temp;
        boolean flag = false;
        //N个数字进行排序，要进行n-1趟排序
        for(int i = 0; i < len - 1;i++)
        {
            //  -i的原因： 当执行一轮后，就找到了一个最大值，下次排序时，就不需要对他进行排序了
            for(int j = 0; j < len - i - 1;j++)
            {
                if(arr[j] > arr[j+1])
                {
                    flag = true;
                    temp = arr[j+1];
                    arr[j+1] = arr[j];
                    arr[j] = temp;
                }
            }
            if(!flag)
                break;
            else
                flag = false;
        }
       System.out.println(Arrays.toString(arr));

    }
}