冒泡排序

1.什麼是冒泡排序?

    冒泡排序（Bubble Sort），是一種計算機科學領域的較簡單的排序算法。它重複地走訪過要排序的數列，一次比較兩個元素，若是他們的順序錯誤就把他們交換過來。走訪數列的工做是重複地進行直到沒有再須要交換，也就是說該數列已經排序完成。
這個算法的名字由來是由於越大的元素會經由交換慢慢「浮」到數列的頂端，故名。

2.算法的原理是什麼? (從後往前)

a.比較兩個相鄰元素的大小,若是第二個比第一個大,則交換它們.
b.從第一對元素比較到最後一對,最後元素會是最小元素.
c.對全部元素重複上述步驟,除了最後一個.

如:[6 2 4 1 5 9]

3.簡單java實現

public void sort(int[] arr) {
    int temp = 0;
    for (int i=arr.length-1; i>0; --i) {
        for (int j=0; j<i; j++) {
            // 比較相鄰元素
            if (arr[j+1] > arr[j]) {
                temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
    }
}

4.如何改進算法呢?
    例如: [5 6 4 3 2 1]這組數據,通過一趟排序後爲[6 5 4 3 2 1],以後的循環再從第二個元素繼續比較每組相鄰元素並無意義,即不執行if語句內代碼,能夠從這裏改善算法.增長一個布爾變量用於判斷是否排序完成,完成則不須要執行if語句內代碼.

改進一以下:

public void sort2(int[] arr) {
    int temp = 0;
    boolean swaped;
    for (int i=arr.length-1; i>0; --i) {
        swaped = false;
        for (int j=0; j<i; j++) {
            // 比較相鄰元素
            if (arr[j+1] > arr[j]) {
                temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
                swaped = true;
            }
        }
        if (!swaped) {
            break;
        }
    }
}

5.該算法還能改進嗎?
    例如: [6 7 5 8 4 3 2 1]這組數據
通過一趟排序後爲[7 6 8 5 4 3 2 1]最後一組比較元素爲 2 和 1;
通過第二趟排序後爲[7 8 6 5 4 3 2 1]最後一組比較元素爲3 和 2;
通過第三趟排序後爲[8 7 6 5 4 3 2 1]最後一組比較元素爲4 和 3;
    觀察可知:
在第一趟排序後 5 4 3 2 1已排好序,因此下趟排序只須要到6便可便可,即最後一組比較元素爲6和8便可.
結合改進一判斷交換標誌位
改進二以下:

public void sort3(int[] arr) {
    int temp = 0;
    int lastSwap = arr.length - 1;
    int lastSwapTemp = lastSwap;
    for (int i=arr.length-1; i>0; --i) {
        lastSwap = lastSwapTemp;
        for (int j=0; j<lastSwap; ++j) {
            if (arr[j+1] > arr[j]) {
                temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
                lastSwapTemp = j;
            }
        }
        if (lastSwapTemp == lastSwap) {
            break;
        }
    }
}

6.算法複雜度

• 最好複雜度爲O(n),數據爲正序
• 最壞複雜度爲O(n^2),數據爲逆序
• 平均複雜度爲O(n^2)

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

8.雞尾酒排序(冒泡排序改進版)
雞尾酒排序也就是定向冒泡排序, 雞尾酒攪拌排序, 攪拌排序 (也能夠視做選擇排序的一種變形), 漣漪排序, 來回排序 or 快樂小時排序, 是冒泡排序的一種變形。此演算法與冒泡排序的不一樣處在於排序時是以雙向在序列中進行排序。

java實現:

public static void coktailSort(int[] arr) {
        int left = 0;
        int right = arr.length-1;
        while (left < right) {
            //將最小元素放到後面
            for (int i=left; i<right; i++) {
                if (arr[i+1] > arr[i]) {
                    swapElement(arr, i, i+1);
                }
            }
            right--;

            //將最大元素放到前面
            for (int i=right; i>left; i--) {
                if (arr[i-1] < arr[i]) {
                    swapElement(arr, i-1, i);
                }
            }
            left++;
        }
    }

    private static void swapElement(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }