冒泡排序（Bubble Sort）

最簡單的排序

冒泡排序幾乎是所有排序中思想最爲簡單的排序，很好理解。
每次比較兩個數，將較大（或較小）的數升上去，這個過程就像氣泡逐漸上升一樣。這裏將較大的數升上去爲例：

原始待排序數組| 6 | 2 | 4 | 1 | 5 | 9 |

第一趟排序(外循環)

第一次兩兩比較6 > 2交換(內循環)

交換前狀態| 6 | 2 | 4 | 1 | 5 | 9 |
交換後狀態| 2 | 6 | 4 | 1 | 5 | 9 |


第二次兩兩比較,6 > 4交換

交換前狀態| 2 | 6 | 4 | 1 | 5 | 9 |
交換後狀態| 2 | 4 | 6 | 1 | 5 | 9 |


第三次兩兩比較,6 > 1交換

交換前狀態| 2 | 4 | 6 | 1 | 5 | 9 |
交換後狀態| 2 | 4 | 1 | 6 | 5 | 9 |


第四次兩兩比較,6 > 5交換

交換前狀態| 2 | 4 | 1 | 6 | 5 | 9 |
交換後狀態| 2 | 4 | 1 | 5 | 6 | 9 |


第五次兩兩比較,6 < 9不交換

交換前狀態| 2 | 4 | 1 | 5 | 6 | 9 |
交換後狀態| 2 | 4 | 1 | 5 | 6 | 9 |

第二趟排序(外循環)

第一次兩兩比較2 < 4不交換

交換前狀態| 2 | 4 | 1 | 5 | 6 | 9 |
交換後狀態| 2 | 4 | 1 | 5 | 6 | 9 |



第二次兩兩比較,4 > 1交換

交換前狀態| 2 | 4 | 1 | 5 | 6 | 9 | 
交換後狀態| 2 | 1 | 4 | 5 | 6 | 9 |



第三次兩兩比較,4 < 5不交換

交換前狀態| 2 | 1 | 4 | 5 | 6 | 9 | 
交換後狀態| 2 | 1 | 4 | 5 | 6 | 9 |



第四次兩兩比較,5 < 6不交換

交換前狀態| 2 | 1 | 4 | 5 | 6 | 9 |
交換後狀態| 2 | 1 | 4 | 5 | 6 | 9 |

第三趟排序(外循環)

第一次兩兩比較2 > 1交換

交換後狀態| 2 | 1 | 4 | 5 | 6 | 9 |
交換後狀態| 1 | 2 | 4 | 5 | 6 | 9 |



第二次兩兩比較,2 < 4不交換

交換後狀態| 1 | 2 | 4 | 5 | 6 | 9 | 
交換後狀態| 1 | 2 | 4 | 5 | 6 | 9 |



第三次兩兩比較,4 < 5不交換

交換後狀態| 1 | 2 | 4 | 5 | 6 | 9 | 
交換後狀態| 1 | 2 | 4 | 5 | 6 | 9 |

第四趟排序(外循環)無交換

第五趟排序(外循環)無交換

至此排序算法執行結束

算法分析及實現代碼

按上述的步驟來說，時間複雜度爲O（n²）
C++實現代碼

template <typename T>
void bubbleSort(T arr[], int n)
{
    for (int i = 0; i < n - 1; i++)
    {
        for (int j = 0; j < n - 1 - i; j++)
        {
            if (arr[j] > arr[j + 1])
            {
                swap(arr[j] ，arr[j + 1]);
            }
        }
    }
}

這個爲最簡單的實現方法，還沒有任何的優化。

void bubbleSort(T arr[], int n){
    bool swapped;
    do{
        swapped = false;
        for (int i = 1; i < n; i++){
            if (arr[i - 1] > arr[i]){
                swap(arr[i - 1], arr[i]);
                swapped = true;
            }
        }
        n--;
    } while (swapped);
}

這裏的優化在於會在排好序後不再進行循環。根據優化過的代碼，當最好情況的時候，冒泡排序的時間複雜度是O(n）