冒泡排序

冒泡排序（Bubble Sort）重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。

冒泡排序算法的运作如下:
1、比较相邻的元素。如果第一个比第二个大，就交换他们两个。
2、对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
3、 针对所有的元素重复以上的步骤，除了最后一个。
4、持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

Java代码：

public class BubbleSorter {
    public static void sort(int[] a) {
        sort(a, 0, a.length);
    }

    public static void sort(int[] a, int fromIndex, int toIndex) {
        // i 为内层循环比较次数
        for (int i = a.length - 1; i >= 0; i--) {
            boolean swap = false;
            for (int j = 0; j < i; j++) {
                if (a[j] > a[j+1]) {
                    swap(a, j, j+1);
                    swap = true;
                }
            }
            if (!swap) break;
        }
    }

    private static void swap(int[] a, int i, int j) { int temp = a[i]; a[i] = a[j]; a[j] = temp; }
    private static void swap(Object[] a, int i, int j) { Object temp = a[i]; a[i] = a[j]; a[j] = temp; }

    public static void sort(Object[] a) {
        sort(a, 0, a.length);
    }

    @SuppressWarnings("unchecked")
    public static void sort(Object[] a, int fromIndex, int toIndex) {
        // i 为内层循环比较次数
        for (int i = a.length - 1; i >= 0; i--) {
            boolean swap = false;
            for (int j = 0; j < i; j++) {
                if (((Comparable)a[j]).compareTo(a[j+1]) > 0) {
                    swap(a, j, j+1);
                    swap = true;
                }
            }
            if (!swap) break;
        }
    }


    public static <T> void sort(T[] a, Comparator<? super T> c) {
        sort(a, 0, a.length, c);
    }

    public static <T> void sort(T[] a, int fromIndex, int toIndex, Comparator<? super T> c) {
        // i 为内层循环比较次数
        for (int i = a.length - 1; i >= 0; i--) {
            boolean swap = false;
            for (int j = 0; j < i; j++) {
                if (c.compare(a[j], a[j+1]) > 0) {
                    swap(a, j, j+1);
                    swap = true;
                }
            }
            if (!swap) break;
        }
    }
}

注：代码来自算法导论的Java实现