冒泡排序（Bubble Sort）原理及Java實現

冒泡排序 (Bubble Sort) 算法是一種基於交換的排序算法，其思想是，依次比較相鄰元素的大小，如果反序，則進行交換，然後再進行下一次排序——如果數據集合的長度爲n ，則下一次對前n-1的數據進行冒泡排序。 

比如：

 第一趟排序 ：R1 和R2 比較， R2 和 R3 比較  .... Rn-1 和Rn 比較。得到最大值或最小值Rn

 第二趟排序： R1 和R2 比較， R2 和 R3 比較  .... Rn-2 和Rn-1 比較。得到最大值或最小值前n-1個數中的最值 Rn-1

..........................

直到只剩下最後一個數 R1 爲有序。

但是，實現的時候一般換另一種方法，用R1 和後面的 n-1 個數依次比較 得到一個最值R1 ——這是第一趟冒泡排序；

第二趟冒泡排序： 用R2 和後面的n-2個數比較 ，得到一個最值 R2 ....

依次執行，直到最後剩下Rn爲有序。

如對R = {37, 40, 38, 42, 461, 5, 7, 9, 12}進行冒泡排序；

初始序列	37	40	38	42	461	5	7	9	12
第一趟排序	5	40	38	42	461	37	7	9	12
第二趟排序	5	7	40	42	461	38	37	9	12
第三趟排序	5	7	9	42	461	40	38	37	12
第四趟排序	5	7	9	12	461	42	40	38	37
第五趟排序	5	7	9	12	37	461	42	40	38
第六趟排序	5	7	9	12	37	38	461	42	40
第七趟排序	5	7	9	12	37	38	40	461	42
第八趟排序	5	7	9	12	37	38	40	42	461

第九趟排序的時候已經有序。

下面分析一下每一趟排序的結果是如何來的，假設爲順序存儲：

集合R	37	40	38	42	461	5	7	9	12
元素位置	1	2	3	4	5	6	7	8	9

在第一次排序過程中，用R1 = 37 ， 和後面的 Ri ( 1<i <= 9)比較 ， 發現 R1 > R6 ， 交換位置，得到新的排列：

集合R	5	40	38	42	461	37	7	9	12
元素位置	1	2	3	4	5	6	7	8	9

發現沒有比R1=5 ， 小的元素，第一趟排序結束。

第二趟排序R2=40，發現R3 比R2交換得到新的排列

集合R	5	38	40	42	461	37	7	9	12
元素位置	1	2	3	4	5	6	7	8	9

繼續比較，發現R2 比R6大 交換位置得到新的排列

集合R	5	37	40	42	461	38	7	9	12
元素位置	1	2	3	4	5	6	7	8	9

繼續比較，發現R2 比R7大，交換得到新的排列

集合R	5	7	40	42	461	38	37	9	12
元素位置	1	2	3	4	5	6	7	8	9

繼續比較，沒有比R2 = 7 更小的元素， 第二趟排序結束。有興趣的童鞋可以自己推到一偏。

以此類推，知道Ri = n-1 = 8；

以下是上述思想的Java實現版：

public static void bubbleSort(int[] array) {
        if (null == array || array.length == 0)
            return;
        int temp;
        for (int i = 0; i < array.length - 1; i++) {
            for (int j = i + 1; j < array.length; j++) {
                if (array[j] < array[i]) {
                    temp = array[j];
                    array[j] = array[i];
                    array[i] = temp;
                }
            }
        }
    }