python算法與數據結構-冒泡排序算法(32)

時間 2019-11-15

原文原文鏈接

1、冒泡排序介紹

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

2、冒泡排序原理

比較相鄰的元素。若是第一個比第二個大，就交換他們兩個。
對每一對相鄰元素作一樣的工做，從開始第一對到結尾的最後一對。這一步作完，最後的元素應該會是最大的數。
針對全部的元素重複以上的步驟，除了最後一個。
持續每次對愈來愈少的元素重複上面的步驟，直到沒有任何一對數字須要比較。

3、冒泡排序圖解

4、冒泡排序總結

有N個數據須要比較N-1趟
每趟比較N-i次,i表示第幾趟，例如7個數據，第四趟須要比較 7-4 = 3次

5、冒泡排序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]

6、冒泡排序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

7、冒泡排序的優化

　　經過上面的案例咱們已經知道冒泡排序的原理和實現過程，可是在處理一些特殊數據上的時候，咱們還能夠對冒泡排序優化，例如：一個數組原本就是有序，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)

運行結果爲：spa

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

C語言代碼實現以下：3d

#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;
}

運行結果爲：code

打印排序後的數組是：
2 7 8 13 19 25 34

8、冒泡排序的時間複雜度

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

9、冒泡排序算法的穩定性

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