冒泡排序

冒泡排序可以說是最簡單的一種排序，當然，復雜度也是最高的

冒泡排序的實現過程：兩兩之間相互比較，當前者比後者大的時候，兩者交換（假設是升序排列）。

那麽給出簡單的冒泡排序算法：

#define MAXSIZE 10
void swap(SqList *L, int i, int j)
{
    int temp = L->r[i];
    L->r[i] = L->r[j];
    L->r[j] = temp;
}
typedef struct {
    int r[MAXSIZE + 1];
    int length;
}  SqList;
void
 
 BubbleSort0(SqList *L)
{
    int line, col;
    for (line = 0; line < L->length - 1; line++)
    {
         for (col = line + 1； col <  L->length; col++)
         {
             if (L->a[line]  > L->a[col])
             {
                    swap(L, line, col)
             }
         }
}
 

這是最簡單的一種排序算法，也是我們所能夠寫出來的，不正宗的冒泡排序。

下面給出一種正宗的冒泡排序：

void BubbleSort1(SqList *L)
{
    int line, low;
    for (line = 0; line < L->length - 1; line++)
    {
        for (low = L->length - 1; low >= line; low--)
        {
            if (L->r[low] > L->r[low + 1])
            {    
                swap(L, line, low);
            }
        }
    }
}
 

顯然,這種排序算法相較於上一種就好了很多，後面的數據經過比較逐漸的浮上（前）來，並且稍微小一點的（比浮上來的第一個略大）的數據也經過這次排序而浮到前面上來。而上一種是每一個與其後面的每一個都進行一次對比。

冒泡排序還能不能改進呢？

答案是能。

設想一下：如果沒有數據交換或者數據交換很少的話，會是怎樣的一種情況？

比方說 {2， 1， 3， 4， 5， 6， 7， 8， 9}，對它進行排序，顯然，除了1 和 2交換之外，沒有其他的數據進行交換，但是如果沿用上面的算法，盡管不用進行數據交換，我們還是要進行for循環，將兩兩之間進行比較（畢竟計算機不知道這個數組到底有沒有序）。那麽，我們就可以想一個改進方法，如果沒有數據交換，就不進行比較。

具體改進代碼如下：

void BubbleSort2(SqList *L)
{
    int line, col;
    bool flag = True;
    for (line = 0; line < L->length - 1 && flag; line++)
    {
        flag = False;
        for (col = L->length - 1; col >= line ; low--)
        {
            if (a[col] > a[col + 1])
            {
                swap(L, col, col + 1);
                flag = True;      //如果有數據交換，那麽flag 就為真，如果沒有，就為假
            }
        }
    }
}

以上。

先寫這麽點。。

因為舍友太過吵鬧無法入睡，所以才寫的。。。

真尼瑪悲傷。。

差點忘了復雜度分析：

這個算法的復雜度是O(n^2),具體分析如下：

最糟的狀況，就是原排序和我們所要的排序完全相反，比如說我們要的是{1, 2, 3, 4, 5}，而原來的數列卻是{5， 4， 3， 2， 1}，那麽這樣的話，每一步比較都需要換位，第一次需要比較並移動4次，第二個需要比較並移動3次，第三個需要比較並移動兩次，第四個需要比較並移動1次，總共是10次，也就是 （n - 1) + (n - 2) + (n - 3) + ......+ 1 = n(n - 1) / 2。

而最好的情況，當然是一次都不用移動啦，這個時候算法復雜度就是O(n)。

排序算法（1）——冒泡排序