Java（.NET）經典排序算法之冒泡排序

轉自：http://blog.csdn.net/ouyang_peng/article/details/46540497

冒泡排序（Bubble Sort）是一種簡單的排序算法。它重複地走訪過要排序的數列，一次比較兩個元素，如果他們的順序錯誤就把他們交換過來。走訪數列的工作是重複地進行直到沒有再需要交換，也就是說該數列已經排序完成。這個算法的名字由來是因爲越小的元素會經由交換慢慢“浮”到數列的頂端。

一、算法原理

　　 冒泡排序算法的運作如下：

1、比較相鄰的元素。如果第一個比第二個大，就交換他們兩個。

2、對每一對相鄰元素作同樣的工作，從開始第一對到結尾的最後一對。在這一點，最後的元素應該會是最大的數。

3、 針對所有的元素重複以上的步驟，除了最後一個。

4、 持續每次對越來越少的元素重複上面的步驟，直到沒有任何一對數字需要比較。

二、算法分析

時間複雜度

算法穩定性

冒泡排序就是把小的元素往前調或者把大的元素往後調。比較是相鄰的兩個元素比較，交換也發生在這兩個元素之間。所以，如果兩個元素相等，我想你是不會再無聊地把他們倆交換一下的；如果兩個相等的元素沒有相鄰，那麼即使通過前面的兩兩交換把兩個相鄰起來，這時候也不會交換，所以相同元素的前後順序並沒有改變，所以冒泡排序是一種穩定排序算法。

算法演練

下面動畫演示從最後一個數開始和上一個數比較，如果小於上一個數就交換位置。

ps:讀者也可以自己打開下面的鏈接，自己設定要排序的數組，進行排序演練

冒泡排序動畫演示（http://student.zjzk.cn/course_ware/data_structure/web/flashhtml/maopaopaixu.htm）

三、代碼實現

public class BubbleSortTest {
    /**
     * 冒泡排序
     * @param source
     *            要進行排序的數組
     */
    public static void bubbleSort(int[] source) {
        int length = source.length;
            for (int i = 0; i < length - 1; i++) { //N個數需N-1趟,每趟完成之後,較大元素將冒到數組最末端
                for (int j = 0; j < length - 1 - i; j++) {  //每趟需要比較N-i次比較
                    if (source[j] > source[j + 1]) {
                        swap(source, j, j + 1);
                    }
                    System.out.print("\n外循環第" + (i + 1) + "次,內循環第" + (j + 1)
                            + "次,排序結果：");
                    printArray(source);
                }
                System.out.println("");
            }
    }

    /**
     * 交換x、y下標指向的值
     *
     * @param source
     *            要進行交換的數組
     * @param x
     *            數組下標x
     * @param y
     *            數組下標x
     */
    private static void swap(int[] source, int x, int y) {
        int temp = source[x];
        source[x] = source[y];
        source[y] = temp;
    }

    /**
     * 遍歷數組然後打印
     * @param source 要打印的數組
     */
    private static void printArray(int[] source) {
        for (int i = 0; i < source.length; i++) {
            System.out.print("\t" + source[i]);
        }
    }

    public static void main(String[] args) {
        int[] source = { 24, 19, 26, 39, 36, 7, 31, 29, 38, 23 };

        System.out.println("排序前：");
        printArray(source);
        System.out.println("\n");

        bubbleSort(source);

        System.out.println("\n\n排序後：");
        printArray(source);
    }
}

四、運行結果

排序前：
    24  19  26  39  36  7   31  29  38  23


外循環第1次,內循環第1次,排序結果： 19  24  26  39  36  7   31  29  38  23
外循環第1次,內循環第2次,排序結果： 19  24  26  39  36  7   31  29  38  23
外循環第1次,內循環第3次,排序結果： 19  24  26  39  36  7   31  29  38  23
外循環第1次,內循環第4次,排序結果： 19  24  26  36  39  7   31  29  38  23
外循環第1次,內循環第5次,排序結果： 19  24  26  36  7   39  31  29  38  23
外循環第1次,內循環第6次,排序結果： 19  24  26  36  7   31  39  29  38  23
外循環第1次,內循環第7次,排序結果： 19  24  26  36  7   31  29  39  38  23
外循環第1次,內循環第8次,排序結果： 19  24  26  36  7   31  29  38  39  23
外循環第1次,內循環第9次,排序結果： 19  24  26  36  7   31  29  38  23  39

外循環第2次,內循環第1次,排序結果： 19  24  26  36  7   31  29  38  23  39
外循環第2次,內循環第2次,排序結果： 19  24  26  36  7   31  29  38  23  39
外循環第2次,內循環第3次,排序結果： 19  24  26  36  7   31  29  38  23  39
外循環第2次,內循環第4次,排序結果： 19  24  26  7   36  31  29  38  23  39
外循環第2次,內循環第5次,排序結果： 19  24  26  7   31  36  29  38  23  39
外循環第2次,內循環第6次,排序結果： 19  24  26  7   31  29  36  38  23  39
外循環第2次,內循環第7次,排序結果： 19  24  26  7   31  29  36  38  23  39
外循環第2次,內循環第8次,排序結果： 19  24  26  7   31  29  36  23  38  39

外循環第3次,內循環第1次,排序結果： 19  24  26  7   31  29  36  23  38  39
外循環第3次,內循環第2次,排序結果： 19  24  26  7   31  29  36  23  38  39
外循環第3次,內循環第3次,排序結果： 19  24  7   26  31  29  36  23  38  39
外循環第3次,內循環第4次,排序結果： 19  24  7   26  31  29  36  23  38  39
外循環第3次,內循環第5次,排序結果： 19  24  7   26  29  31  36  23  38  39
外循環第3次,內循環第6次,排序結果： 19  24  7   26  29  31  36  23  38  39
外循環第3次,內循環第7次,排序結果： 19  24  7   26  29  31  23  36  38  39

外循環第4次,內循環第1次,排序結果： 19  24  7   26  29  31  23  36  38  39
外循環第4次,內循環第2次,排序結果： 19  7   24  26  29  31  23  36  38  39
外循環第4次,內循環第3次,排序結果： 19  7   24  26  29  31  23  36  38  39
外循環第4次,內循環第4次,排序結果： 19  7   24  26  29  31  23  36  38  39
外循環第4次,內循環第5次,排序結果： 19  7   24  26  29  31  23  36  38  39
外循環第4次,內循環第6次,排序結果： 19  7   24  26  29  23  31  36  38  39

外循環第5次,內循環第1次,排序結果： 7   19  24  26  29  23  31  36  38  39
外循環第5次,內循環第2次,排序結果： 7   19  24  26  29  23  31  36  38  39
外循環第5次,內循環第3次,排序結果： 7   19  24  26  29  23  31  36  38  39
外循環第5次,內循環第4次,排序結果： 7   19  24  26  29  23  31  36  38  39
外循環第5次,內循環第5次,排序結果： 7   19  24  26  23  29  31  36  38  39

外循環第6次,內循環第1次,排序結果： 7   19  24  26  23  29  31  36  38  39
外循環第6次,內循環第2次,排序結果： 7   19  24  26  23  29  31  36  38  39
外循環第6次,內循環第3次,排序結果： 7   19  24  26  23  29  31  36  38  39
外循環第6次,內循環第4次,排序結果： 7   19  24  23  26  29  31  36  38  39

外循環第7次,內循環第1次,排序結果： 7   19  24  23  26  29  31  36  38  39
外循環第7次,內循環第2次,排序結果： 7   19  24  23  26  29  31  36  38  39
外循環第7次,內循環第3次,排序結果： 7   19  23  24  26  29  31  36  38  39

外循環第8次,內循環第1次,排序結果： 7   19  23  24  26  29  31  36  38  39
外循環第8次,內循環第2次,排序結果： 7   19  23  24  26  29  31  36  38  39

外循環第9次,內循環第1次,排序結果： 7   19  23  24  26  29  31  36  38  39


排序後：
    7   19  23  24  26  29  31  36  38  39

五、雙向冒泡排序

算法原理：

傳統冒泡算法原理

冒泡排序算法的運作如下：（從後往前）

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

雙向冒泡算法原理

雙向冒泡排序算法的運作如下：

1. 傳統冒泡氣泡排序的雙向進行，先讓氣泡排序由左向右進行，再來讓氣泡排序由右往左進行，如此完成一次排序的動作
2. 使用left與right兩個旗標來記錄左右兩端已排序的元素位置。

算法實例：

一個排序的例子如下所示：

排序前：45 19 77 81 13 28 18 1977 11

往右排序：19 45 77 13 28 18 19 7711 [81]

向左排序：[11] 19 45 77 13 28 1819 77 [81]

往右排序：[11] 19 45 13 28 18 19 [77 77 81]

向左排序：[11 13] 19 45 18 28 19 [77 77 81]

往右排序：[11 13] 19 18 28 19 [45 77 77 81]

向左排序：[11 13 18] 19 19 28 [45 77 77 81]

往右排序：[11 13 18] 19 19 [28 45 77 77 81]

向左排序：[11 13 18 19 19] [28 45 77 77 81]

如上所示，括號中表示左右兩邊已排序完成的部份，當left >= right時，則排序完成。

六、代碼實現

package cn.fuxi.ms.sort;

public class DoubleBubbleSortTest {
    /**
     * 雙向冒泡排序
     * 在每一趟排序中，正向冒泡排序將剩餘所有元素中較大的元素冒至剩餘元素最右端，反向冒泡排序將剩餘所有元素中較小的元素冒至剩餘元素最左端
     * @param source
     *            要進行排序的數組
     */
    public static void doubleBubbleSort(int[] source) {
        int length = source.length;
        for (int i = 0, j; i < length / 2; i++) { // N個數需N/2趟
            for (j = i; j < length - 1 - i; j++) { // 每趟需要比較N-i次比較
                if (source[j] > source[j + 1]) {
                    swap(source, j, j + 1);
                }
                System.out.println("第" + (i + 1) + "次正向冒泡,排序結果：");
                printArray(source);
            }
            System.out.println();
            // 添加一層循環,同時從右至左,則每當此for循環結束,較小的數往左邊冒出
            for (--j; j > i; j--) {
                if (source[j - 1] > source[j]) {
                    swap(source, j - 1, j);
                }
                System.out.println("第" + (i + 1) +"次反向冒泡,排序結果：");
                printArray(source);
            }
            System.out.println("");
        }
    }

    /**
     * 交換x、y下標指向的值
     *
     * @param source
     *            要進行交換的數組
     * @param x
     *            數組下標x
     * @param y
     *            數組下標x
     */
    private static void swap(int[] source, int x, int y) {
        int temp = source[x];
        source[x] = source[y];
        source[y] = temp;
    }

    /**
     * 遍歷數組然後打印
     *
     * @param source
     *            要打印的數組
     */
    private static void printArray(int[] source) {
        for (int i = 0; i < source.length; i++) {
            System.out.print("\t" + source[i]);
        }
        System.out.println();
    }

    public static void main(String[] args) {
        int[] source = { 24, 19, 26, 39, 36, 7, 31, 29, 38, 23 };

        System.out.println("排序前：");
        printArray(source);

        doubleBubbleSort(source);

        System.out.println("\n\n排序後：");
        printArray(source);
    }
}

七、打印結果

排序前：
    24  19  26  39  36  7   31  29  38  23
第1次正向冒泡,排序結果：
    19  24  26  39  36  7   31  29  38  23
第1次正向冒泡,排序結果：
    19  24  26  39  36  7   31  29  38  23
第1次正向冒泡,排序結果：
    19  24  26  39  36  7   31  29  38  23
第1次正向冒泡,排序結果：
    19  24  26  36  39  7   31  29  38  23
第1次正向冒泡,排序結果：
    19  24  26  36  7   39  31  29  38  23
第1次正向冒泡,排序結果：
    19  24  26  36  7   31  39  29  38  23
第1次正向冒泡,排序結果：
    19  24  26  36  7   31  29  39  38  23
第1次正向冒泡,排序結果：
    19  24  26  36  7   31  29  38  39  23
第1次正向冒泡,排序結果：
    19  24  26  36  7   31  29  38  23  39

第1次反向冒泡,排序結果：
    19  24  26  36  7   31  29  23  38  39
第1次反向冒泡,排序結果：
    19  24  26  36  7   31  23  29  38  39
第1次反向冒泡,排序結果：
    19  24  26  36  7   23  31  29  38  39
第1次反向冒泡,排序結果：
    19  24  26  36  7   23  31  29  38  39
第1次反向冒泡,排序結果：
    19  24  26  7   36  23  31  29  38  39
第1次反向冒泡,排序結果：
    19  24  7   26  36  23  31  29  38  39
第1次反向冒泡,排序結果：
    19  7   24  26  36  23  31  29  38  39
第1次反向冒泡,排序結果：
    7   19  24  26  36  23  31  29  38  39

第2次正向冒泡,排序結果：
    7   19  24  26  36  23  31  29  38  39
第2次正向冒泡,排序結果：
    7   19  24  26  36  23  31  29  38  39
第2次正向冒泡,排序結果：
    7   19  24  26  36  23  31  29  38  39
第2次正向冒泡,排序結果：
    7   19  24  26  23  36  31  29  38  39
第2次正向冒泡,排序結果：
    7   19  24  26  23  31  36  29  38  39
第2次正向冒泡,排序結果：
    7   19  24  26  23  31  29  36  38  39
第2次正向冒泡,排序結果：
    7   19  24  26  23  31  29  36  38  39

第2次反向冒泡,排序結果：
    7   19  24  26  23  31  29  36  38  39
第2次反向冒泡,排序結果：
    7   19  24  26  23  29  31  36  38  39
第2次反向冒泡,排序結果：
    7   19  24  26  23  29  31  36  38  39
第2次反向冒泡,排序結果：
    7   19  24  23  26  29  31  36  38  39
第2次反向冒泡,排序結果：
    7   19  23  24  26  29  31  36  38  39
第2次反向冒泡,排序結果：
    7   19  23  24  26  29  31  36  38  39

第3次正向冒泡,排序結果：
    7   19  23  24  26  29  31  36  38  39
第3次正向冒泡,排序結果：
    7   19  23  24  26  29  31  36  38  39
第3次正向冒泡,排序結果：
    7   19  23  24  26  29  31  36  38  39
第3次正向冒泡,排序結果：
    7   19  23  24  26  29  31  36  38  39
第3次正向冒泡,排序結果：
    7   19  23  24  26  29  31  36  38  39

第3次反向冒泡,排序結果：
    7   19  23  24  26  29  31  36  38  39
第3次反向冒泡,排序結果：
    7   19  23  24  26  29  31  36  38  39
第3次反向冒泡,排序結果：
    7   19  23  24  26  29  31  36  38  39
第3次反向冒泡,排序結果：
    7   19  23  24  26  29  31  36  38  39

第4次正向冒泡,排序結果：
    7   19  23  24  26  29  31  36  38  39
第4次正向冒泡,排序結果：
    7   19  23  24  26  29  31  36  38  39
第4次正向冒泡,排序結果：
    7   19  23  24  26  29  31  36  38  39

第4次反向冒泡,排序結果：
    7   19  23  24  26  29  31  36  38  39
第4次反向冒泡,排序結果：
    7   19  23  24  26  29  31  36  38  39

第5次正向冒泡,排序結果：
    7   19  23  24  26  29  31  36  38  39




排序後：
    7   19  23  24  26  29  31  36  38  39