冒泡排序的优化详解

这里来讲一讲冒泡排序算法的优化，在学习的过程中，虽然网上给出了优化后的代码，但讲解的不是很清楚，这里尝试来解释清楚。

比如，现在给出五个数 { 2，9，19，6，8 }，要求你用冒泡排序从小到大依次排列。

代码应该是这样的（java）：

public class BubbleSort {

    public static void main(String[] args) {
        int[] data = { 2, 9, 19, 6, 8 };
        bubbleSort(data);
        showSorted(data);
    }

    public static int[] bubbleSort(int[] array) {


        for (int i = 0; i < array.length - 1; i++) {


            for (int j = 0; j < array.length - 1 - i; j++) {

                if (array[j] > array[j + 1]) {
                    int temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                }
            }


        }

        return array;

    }

    public static void showSorted(int[] array) {
        for (int i = 0; i < array.length; i++) {
            System.out.print(+array[i] + ",");
        }

    }

}

来到这里，默认你对上面的基础代码是理解的。接下来，我们要来考虑的是这5个数在4次（5-1次）外循环中是怎样交换位置，分别用A、B、C、D来表示这四次交换，而每次外循环内，又包含了各自次数的内循环。如图：

在上面的图中，我们发现了以下几个问题：

• C、D这两组在做无用功，因为数据到达C时已经是排序好了

• 每次外循环都会将最大的数移到最后的位置，随着循环的增加，后面的数其实已经是排好序的，而下一次循环又得进行无用的比较。

没错，冒泡排序算法的优化就是解决上面两个问题。先看第一个，我们要尽量减少外循环的次数，哪怕一个都好。网上的做法就是引入一个标志性flag来判断在一次外循环中，数据有没有进行交换，代码如下：

public static int[] bubbleSort(int[] array) {

        /* 定义一个flag,默认false */
        boolean flag = false;

        for (int i = 0; i < array.length - 1; i++) {

            /**
             * 每次外循环就设置为true
             */
            flag = true;

            for (int j = 0; j < array.length - 1 - i; j++) {

                if (array[j] > array[j + 1]) {
                    int temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                    // 有变动就设置为false
                    flag = false;
                }
            }

            if (flag) {
                break;
            }

        }

        return array;

    }

经过这样一整，在C次循环后，发现数据没有交换，退出。此时，我们已经成功狙击掉了第D组外循环。

第二个问题怎样解决呢？我们的做法是，尝试来标记循环里最后一次发生数据交换的位置。

注意：在上面的代码中，内循环的循环次数是根据已经确定了后面的数来改变的，但现在，我们要回归，让它每次的内循环次数都是（数组的长度-1），只有这样，才能找到最后一次发生数据交换的位置。

这里，我们定义一个变量K，因为我们要找到最后一次发生数据交换的位置，所以我们要统计循环的个数，这个K会有用处，哦，对了：

k = array.length-1

除此之外，定义一个变量index来标记最后一次发生数据交换的位置，代码如下：

public static int[] bubbleSort(int[] array) {

        /* 定义一个flag,默认false */
        boolean flag = false;

        int k = array.length - 1;

        int index = 0;

        for (int i = 0; i < k; i++) {

            /**
             * 每次外循环就设置为true
             */
            flag = true;

            for (int j = 0; j < k; j++) {

                if (array[j] > array[j + 1]) {
                    int temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                    // 有变动就设置为false
                    flag = false;


                    index = j;
                }
            }

            //统计总共循环了多少次
            k = index;

            if (flag) {
                break;
            }

        }

        return array;

    }

画个图举个栗子：

依次类推，排好序的就不用再进行无用的比较了。

综上，就是冒泡排序的两种优化。