冒泡排序

冒泡排序的思路很简单——从头至尾遍历数组元素，若前一项大于（或小于）后一项，则交换相邻两项。单次遍历整个数组可将某一个元素排列到正确位置，因此需要遍历元素数量n次。在代码中体现也就是内外两层循环，内层循环负责遍历中两两元素的交换操作，外层负责遍历次数控制。

首先看版本1:

/**
 * 冒泡排序效率最低写法，没有任何优化步骤
 * @param arrayToSort
 */
public static void sortAlpha(int[] arrayToSort) {
    for (int i = 0; i < arrayToSort.length; i++) {
        for (int j = 0; j < (arrayToSort.length - 1); j++) {
            int tmp;
            if (arrayToSort[j] > arrayToSort[j + 1]) {
                tmp = arrayToSort[j];
                arrayToSort[j] = arrayToSort[j+1];
                arrayToSort[j+1] = tmp;
            } 
        }
    }
}

很明显的两层循环，这里按从小到大排序，因此弱发现后一元素比当前元素大，则交换两个元素的位置，直到比较到最后一个元素为止。因为是j与j+1比较，为避免数组越界，内层for循环需以arrayToSort.length - 1做边界。

这个版本中没有做任何优化，因为遍历n次后，数组中后n个元素实际已经是排好序的了，因此不需要再进行比较了。所以内层循环还可以进一步优化，得到版本2:

/**
 * 冒泡排序优化版本1，减少内层循环遍历个数，已经排序好的元素无需遍历。
 * @param arrayToSort
 */
public static void sortBeta(int[] arrayToSort) {
    for (int i = 0; i < arrayToSort.length; i++) {
        for (int j = 0; j < (arrayToSort.length - 1 - i); j ++) {
            int tmp;
            if (arrayToSort[j] > arrayToSort[j + 1]) {
                tmp = arrayToSort[j];
                arrayToSort[j] = arrayToSort[j+1];
                arrayToSort[j+1] = tmp;
            }
        }
    }
}

由于遍历n次后，后n项已经排好序了，因此内层循环上界再减去遍历次数即可，即arrayToSort.length - 1 - i这样每次内层遍历便可减少n次比较操作，提升了效率。

虽然这时内层循环已经优化操作次数，但如果给一个部分有序的数列，如

{1, 2, 3, 4, 8, 7, 6, 5}

遍历前四次后，数组实际已经排好序了，这时就不需要再进行比较操作了，因此除了前四次排序，仅在需要一次遍历就可检验出数组有序，也就是公共遍历5次数组就可完成排序了。在当前的逻辑下，会导致出现3次无意义的遍历。
解决这个问题的方案也很简单，若数组已经有序，则不会出现交换操作。因此仅需设定一个标志变量，当有交换时置成需要排序（检验）的状态，当所有元素已经有序，检验过程没有交换操作，那么再下次遍历数组直接退出即可，便是版本3:

/**
 * 冒泡排序优化版2，减少内部排序遍历个数，并且添加了数据是否有序的检验，
 * 若数组已经有序，无需再进行遍历，直接退出。
 * @param arrayToSort
 */
public static void sortGamma(int[] arrayToSort) {
    boolean needSort = true;
    for (int i = 0; i < arrayToSort.length; i++) {
        if (!needSort) {
            break;
        }
        for (int j = 0; j < (arrayToSort.length - 1 - i); j ++) {
            needSort = false;
            int tmp;
            if (arrayToSort[j] > arrayToSort[j + 1]) {
                tmp = arrayToSort[j];
                arrayToSort[j] = arrayToSort[j+1];
                arrayToSort[j+1] = tmp;
                needSort = true;
            }
        }
    }
}

在每次进入内部循环时重置标志变量，若进行了交换操作则相应改变，进入内层循环前进行判断，若不需要再遍历，直接退出。

接下来写一些测试代码，来验证三种方案的效率。生成两个数组：一个完全逆序，长度为9999；另一个完全正序，长度同样为9999（不用再排序了），然后分别使用三种排序，统计排序时间，以下是一种方法的调用：

public static void main(String[] args) {
    final int len = 9999;
    int test[] = new int[len];
    for (int i = 0; i < test.length; i++) {
        test[i] = len - 1 - i;
    }

    int testNoNeedSort[] = new int[len];
    for (int i = 0; i < testNoNeedSort.length; i ++) {
        testNoNeedSort[i] = i;
    }

    long startTimeA = System.currentTimeMillis();
    BubbleSort.sortGamma(test);
    long endTimeA = System.currentTimeMillis();
    System.out.println("Time use A:" + (endTimeA - startTimeA));

    long startTimeB = System.currentTimeMillis();
    BubbleSort.sortGamma(testNoNeedSort);
    long endTimeB = System.currentTimeMillis();
    System.out.println("Time use A:" + (endTimeB - startTimeB));

}

运行三种排序，统计到的时间：

版本	逆序（最差情况）ms	正序（最好情况）ms
版本1	107	66
版本2	62	42
版本3	60	1

最好情况下由于仅需比较，不需要交换，因此三种版本使用时间均比最差情况短，但由于第三种增加了交换情况的判断，仅需遍历一遍就可完成。
最差情况下由于版本2，版本3对内层排序进行了操作数优化，因此显著优于完全没有优化的版本1。