排序：一. 冒泡排序 （前往後所有未排序的元素相鄰比較）

系列文章共實現了六種排序算法：

1. 冒泡排序
2. 直接選擇排序
3. 插入排序
4. 歸併排序
5. 快速排序
6. 堆排序

定義了 Sortable 接口，每種排序方法實現該接口，在 sort 方法中實現排序。

public interface Sortable<T> {

    /**
     * 將數組進行排序
     *
     * @param sour       待排序的數組
     * @param comparator 排序規則
     * @return 數組中元素交換次數
     */
    int sort(T[] sour, Comparator<T> comparator);

}

測試示例如下：

public class Test {

    public static void main(String[] args) {

        Integer[] s = {1, 8, 9, 4, 3, 4, 3, 2, 1};
        Integer[] s1 = {1, 2, 4, 3, 5, 7};
        Integer[] s2 = {1, -2, 22223, 489, 335, 23437, 3, 4, 56, 76, 98, 12, 3421, 654};
        Integer[] s3 = P.getRandomArrays(1000, 10000);
        test2(s2);
    }

    // 測試堆排序
    private static void test2(Integer[] sour) {
        HeapSort heapSort = new HeapSort();
        P.out(sour);
        heapSort.sort(new MiniArrayHeap<>(), sour);
        P.out(sour);
    }

    private static void test1(Integer[] sour) {
        test(new SelectionSort<>(), sour); // 升序 交換 1 次
        test(new SelectionSort<>(), sour); // 升序 交換 5 次
    }

    private static <T extends Comparable> void test(Sortable<T> sortable, T... ts) {
        P.out(sortable.sort(ts, T::compareTo));
        P.out(Arrays.toString(ts));
    }

}

排序算法的穩定性

假定在待排序的記錄序列中，存在多個具有相同的關鍵字的記錄，若經過排序，這些記錄的相對次序保持不變，即在原序列中，ri=rj，且ri在rj之前，而在排序後的序列中，ri仍在rj之前，則稱這種排序算法是穩定的；否則稱爲不穩定的。

穩定性的好處。排序算法如果是穩定的，那麼從一個鍵上排序，然後再從另一個鍵上排序，第一個鍵排序的結果可以爲第二個鍵排序所用。基數排序就是這樣，先按低位排序，逐次按高位排序，低位相同的元素其順序再高位也相同時是不會改變的。

正文

參考文章

時間複雜度O(n2)，最好情況O(n)，最壞情況O(n2)，穩定。

適合數據規模很小的時候，而且它的效率也比較低。

通過重複地走訪要排序的數列，一次比較兩個元素，如果他們的順序錯誤就把他們交換過來。走訪數列的工作是重複地進行直到沒有再需要交換，也就是說該數列已經排序完成。

算法描述如下

1. 比較相鄰的元素。如果第一個比第二個大，就交換他們兩個。
2. 對每一對相鄰元素作同樣的工作，從開始第一對到結尾的最後一對。這步做完後，最後的元素會是最大的數。
3. 針對所有的元素重複以上的步驟，除了最後一個。
4. 持續每次對越來越少的元素重複上面的步驟，直到沒有任何一對數字需要比較。

BubbleSort sort 方法實現如下：

代碼已上傳 GitHub ，可以在 這裏 找到