python演算法與資料結構-氣泡排序(32)

Se7eN_HOU發表於2019-06-22
Python演算法資料結構排序

一、氣泡排序介紹

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

二、氣泡排序原理

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

三、氣泡排序圖解

  

 

 

四、氣泡排序總結

  1. 有N個資料需要比較N-1趟
  2. 每趟比較N-i次,i表示第幾趟，例如7個資料，第四趟需要比較 7-4 = 3次

五、氣泡排序python程式碼實現 

def bubble_sort(numlist):
    # 需要排列的資料個數
    N = len(numlist)
    # i 控制一共需要多少趟 N-1
    for i in range(N-1):
        # j 控制每趟需要比較多少次(因為i是從0開始，所以N-i-1)
        for j in range(N-i-1):
            # 判斷j和j+1兩個位置的資料大小
            if numlist[j]>numlist[j+1]:
                # 交換（交換的程式碼有很多種寫法）
                temp = numlist[j]
                numlist[j] = numlist[j+1]
                numlist[j+1] = temp
            
list = [19,2,13,8,34,25,7]
print("排序前list = %s"%list)
bubble_sort(list)
print("排序後list = %s"%list)

執行結果為：

排序前list = [19, 2, 13, 8, 34, 25, 7]
排序後list = [2, 7, 8, 13, 19, 25, 34]

六、氣泡排序C語言程式碼實現

#include <stdio.h>
// 建立一個冒泡函式，需要傳遞一個陣列,和陣列的長度
void bubble_sort(int array[],int arrayLength)
{
    // i 控制一共需要迴圈多少趟，
    for (int i=0; i<arrayLength-1; i++)
    {
        // j 控制每趟迴圈多少次
        for (int j=0; j<arrayLength-i-1; j++)
        {
            //判斷j和j+1位置上數的大小
            if (array[j]>array[j+1])
            {
                //交換
                int temp = array[j];
                array[j] = array[j+1];
                array[j+1] = temp;
            }
        }
    }
}

int main(int argc, const char * argv[])
{
    // 函式的宣告
    void bubble_sort(int array[],int arrayLength);
    // 建立一個陣列
    int numArray[] = {19,2,13,8,34,25,7};
    //進行排序
    bubble_sort(numArray,7);
   
    printf("列印排序後的陣列是：\n");
    for (int i=0; i<7; i++)
    {
        printf("%d ",numArray[i]);
    }
    return 0;
}

運算結果為：

列印排序後的陣列是：
2 7 8 13 19 25 34

七、氣泡排序的優化

　　通過上面的案例我們已經知道氣泡排序的原理和實現過程，但是在處理一些特殊資料上的時候，我們還可以對氣泡排序優化，例如：一個陣列本來就是有序，1，2，3，4，5，6，7，這樣的一個陣列已經是正確的順序的，我們只需要比較一趟後，發現這一趟所有的資料都沒有發生改變，就說明這已經是一個正確的順序的，後面的迴圈就沒必要迴圈下去了，這樣便能提高程式的效率，而我們只需要在氣泡排序的程式碼中，判斷是否這一樣都沒發生交換即可。

python程式碼實現如下：

def bubble_sort(numlist):
    # 需要排列的資料個數
    N = len(numlist)
    # i 控制一共需要多少趟 N-1
    for i in range(N-1):
        
        # 定義一個變數，用於記錄是否在本趟中發生了交換
        isChange = 0
        
        # j 控制每趟需要比較多少次(因為i是從0開始，所以N-i-1)
        for j in range(N-i-1):
            # 判斷j和j+1兩個位置的資料大小
            if numlist[j]>numlist[j+1]:
                # 交換（交換的程式碼有很多種寫法）
                temp = numlist[j]
                numlist[j] = numlist[j+1]
                numlist[j+1] = temp
                # 只要發生了交換，我們就改變isChange的值為1
                isChange = 1
        
        # 只要isChange =0說明已經是正確順序了，直接break即可
        if isChange == 0:
            break
            
list = [19,2,13,8,34,25,7]
print("排序前list = %s"%list)
bubble_sort(list)
print("排序後list = %s"%list)

執行結果為：

排序前list = [19, 2, 13, 8, 34, 25, 7]
排序後list = [2, 7, 8, 13, 19, 25, 34]

C語言程式碼實現如下：

#include <stdio.h>
// 建立一個冒泡函式，需要傳遞一個陣列,和陣列的長度
void bubble_sort(int array[],int arrayLength)
{
    // i 控制一共需要迴圈多少趟，
    for (int i=0; i<arrayLength-1; i++)
    {
        //定義一個變數，用於記錄是否在本趟中發生了改變
        int isChange = 0;
        // j 控制每趟迴圈多少次
        for (int j=0; j<arrayLength-i-1; j++)
        {
            //判斷j和j+1位置上d數的大小
            if (array[j]>array[j+1])
            {
                //交換
                int temp = array[j];
                array[j] = array[j+1];
                array[j+1] = temp;
                // 只要發生了交換，我們就改變isChange的值為1
                isChange = 1;
            }
        }
        // 只要isChange =0說明已經是正確順序了，直接break即可
        if (isChange == 0)
        {
            break;
        }
    }
}

int main(int argc, const char * argv[])
{
    // 函式的宣告
    void bubble_sort(int array[],int arrayLength);
    // 建立一個陣列
    int numArray[] = {19,2,13,8,34,25,7};
    //進行排序
    bubble_sort(numArray,7);
   
    printf("列印排序後的陣列是：\n");
    for (int i=0; i<7; i++)
    {
        printf("%d ",numArray[i]);
    }
    return 0;
}

執行結果為：

列印排序後的陣列是：
2 7 8 13 19 25 34

八、氣泡排序的時間複雜度

  • 最優時間複雜度：O(n) （表示遍歷一次發現沒有任何可以交換的元素，排序結束。）
  • 最壞時間複雜度：O(n2)

九、氣泡排序演算法的穩定性 

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

相關文章