冒泡排序的优化

冒泡排序的优化主要是三个点：
1.使用异或运算，使元素交换时不用临时变量：

array[j] ^= array[j + 1];
array[j + 1] ^= array[j];
array[j] ^= array[j + 1];

2.在外部循环时，设置一个标记，如果整轮比较之后，内部元素交换都没有交换，说明已经是ok的顺序，此时不用再继续

    public static void sortWithFlag(int[] array) {
        if (array == null || array.length < 2) {
            return;
        }

        boolean flag = true;
        int internalCount = 0;
        int outerCount = 0;
        for (int i = 0; i < array.length - 1; i++) {
            for (int j = 0; j < array.length - 1 - i; j++) {
                internalCount++;
                if (array[j] > array[j + 1]) {
                    array[j] ^= array[j + 1];
                    array[j + 1] ^= array[j];
                    array[j] ^= array[j + 1];
                    flag = false;
                }
            }
            outerCount++;
            if (flag) {
                break;
            } else {
                flag = true;
            }
        }
        System.out.println("internalCount = " + internalCount);
        System.out.println("outerCount = " + outerCount);
    }

3.在内部循环时，记录一下最后的比较位置，一轮完成后，下一轮的内部只冒泡到最后交换位置的元素。

    public static void sortWithInternalPosition(int[] array) {
        if (array == null || array.length < 2) {
            return;
        }

        boolean flag = true;
        int current = array.length - 1;
        int position = 0;
        int internalCount = 0;
        int outerCount = 0;
        for (int i = 0; i < array.length - 1; i++) {
            for (int j = 0; j < current; j++) {
                internalCount++;
                if (array[j] > array[j + 1]) {
                    array[j] ^= array[j + 1];
                    array[j + 1] ^= array[j];
                    array[j] ^= array[j + 1];
                    flag = false;
                    position = j;
                }
            }
            outerCount++;
            if (flag) {
                break;
            } else {
                flag = true;
                current = position;
            }

        }
        System.out.println("internalCount = " + internalCount);
        System.out.println("outerCount = " + outerCount);
    }

　　可以看看最后，2和3的比较，虽然比较的总轮数没有变化，但是总的比较次数减少了：