常見演算法效率比較：

一. 氣泡排序

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

1.氣泡排序演算法的運作如下：

（1）比較相鄰的元素。如果第一個比第二個大（升序），就交換他們兩個

（2）對每一對相鄰元素作同樣的工作，從開始第一對到結尾的最後一對。這步做完後，最後的元素還是最大的數

（3）針對所有的元素重複以上的步驟，除了最後一個

2.氣泡排序的分析：

交換過程圖示（第一次）

那麼我們需要進行n-1次冒泡過程，每次對應的比較次數如下圖所示

程式碼如下：

def bubble_sort(alist):
      # j為每次遍歷需要比較的次數，是逐漸減小的
      for j in range(len(alist)-1,0,-1):
           for i in range(j):
                if alist[i] > alist[i+1]:
                    alist[i], alist[i+1] = alist[i+1],alist[i] 
li = [1,3, 4, 5, 2, 11, 6, 9, 15]
bubble_sort(li)
print(li)
 

3. 時間複雜度

演算法的時間複雜度是指演算法執行的過程中所需要的基本運算次數

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

（2）最壞時間複雜度：O(n²)

（3）穩定性：穩定

假定在待排序的記錄序列中，存在多個具有相同的關鍵字的記錄，若經過排序，這些記錄的相對次序保持不變，即在原序列中，ri=rj，且ri在rj之前，而在排序後的序列中，ri仍在rj之前，則稱這種排序演算法是穩定的；否則稱為不穩定的

常見演算法的穩定性（要記住） 堆排序、快速排序、希爾排序、直接選擇排序不是穩定的排序演算法，而基數排序、氣泡排序、直接插入排序、折半插入排序、歸併排序是穩定的排序演算法。 二. 選擇排序 選擇排序是一種簡單直觀的排序演算法。他的工作原理如下： 首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置（末尾位置），然後，再從剩餘未排序元素中繼續尋找最小（大）元素，然後放到已排序序列的末尾。以此類推，直到所有元素均排序完畢 選擇排序的主要優點與資料移動有關。如果某個元素位於正確的最終位置上，則它不會被移動。選擇排序每次交換一對元素，他們當中至少有一個將被移到最終位置上，因此對n個元素的表進行排序總共進行至多n-1次交換。在所有的完全依靠交換去移動 元素的排序方法中，選擇排序屬於非常好的一種 1. 選擇排序分析 排序過程： 紅色表示當前最小值，黃色表示已排序列，藍色表示當前位置

具體程式碼：

def selection_sort(alist):
    for i in range(len(alist)-1):　　　　 # 定義最小數對應的下標，一開始為0
        min_index = i
        for j in range(i+1,n):
            if alist[j] < alist[min_index]:                # 交換下標，資料不進行交換
                min_index = j
        if min_index != i:
            alist[min_index], alist[i] = alist[i], alist[min_index]

2. 時間複雜度

（1）最優時間複雜度：O(n²)

（2）最壞時間複雜度：O(n²)

（3）穩定性：不穩定（升序的時候不穩定，相等兩個數的相對位置一定會發生變化）

三. 插入排序 插入排序是一種簡單直觀的排序演算法。它的工作原理是通過構建有序序列，對於未排序資料，在已排序序列中從後向前掃描，找到相應位置並插入。插入排序在從後向前掃描的過程中，需要反覆把已排序元素逐步向後挪位，為最新元素提供插入空間 1.插入排序分析：

程式碼實現：

def insert_sort(alist):
    # 從第二個元素開始向前插入
    for i in range(1, len(alist)):
        for j in range(i, 0, -1):
            if alist[j] < alist[j-1]:
                alist[j], alist[j-1] = alist[j-1], alist[j]

2. 時間複雜度 （1）最優時間複雜度：O(n)（升序排列，序列已經處於升序狀態） （2）最壞時間複雜度：O(n²) （3）穩定性：穩定 四. 快速排序 快速排序，又稱劃分交換排序。通過一趟排序將要排序的資料分割成獨立的兩部分，其中一部分的所有資料都要小，然後再按此方法對兩部分資料分別進行快速排序，整個排序過程可以遞迴進行，以此達到整個資料變成有序序列 步驟為： （1） 從數列中挑選一個元素，稱為“基準” （2） 重新排序數列，所有元素比基準值小的擺放在基準前面，所有元素比基準值大的擺在基準的後面（相同的數可以放到任意一邊，但一般都統一放到一邊）。在這個分割槽結束之後，該基準就處於數列的中間位置。這個稱為分割槽操作 （3）遞迴的把小於基準值元素的子數列和大於基準值元素的子數列排序 遞迴的最底部情形，是數列的大小基準值元素的子數列和大於基準值元素的子數列排序 1.快速排序的分析：

程式碼如下：

def quick_sort(alist, start, end):
    """快速排序"""
    # 遞迴的退出條件
    if start >= end:
        return
    # 設定起始元素為要尋找位置的基準元素
    mid = alist[start]
    # low為序列左邊的由左向右移動的遊標
    low = start
    # high為序列右邊的由右向左移動的遊標
    high = end

    while low < high:
        # 如果low與high未重合，high指向的元素不比基準元素小，則high向左移動
        while low < high and alist[high] >= mid:
            high -= 1
        # 將high指向的元素放到low的位置上
        alist[low] = alist[high]

        # 如果low與high未重合，low指向的元素比基準元素小，則low向右移動
        while low < high and alist[low] < mid:
            low += 1
        # 將low指向的元素放到high的位置上
        alist[high] = alist[low]

    # 退出迴圈後，low與high重合，此時所指位置為基準元素的正確位置
    # 將基準元素放到該位置
    alist[low] = mid

    # 對基準元素左邊的子序列進行快速排序
    quick_sort(alist, start, low-1)

    # 對基準元素右邊的子序列進行快速排序
    quick_sort(alist, low+1, end)

2. 時間複雜度

（1）最優時間複雜度：O(nlogn)

（2）最壞時間複雜度：O(n²)

（3）穩定性：不穩定

五 希爾排序過程

希爾排序是插入排序的一種，也稱縮小增量排序，是直接插入排序演算法的一種更高效的改進版本。希爾排序是非穩定排序演算法。希爾排序是把記錄按下標的一定增量分組，對每組使用直接插入排序演算法排序；隨著增量逐漸減少，每組包含的關鍵詞越來越多，當增量減至1時，整個檔案恰被分成一組，演算法便終止。

1.程式碼實現：

def shell_sort(alist):
    n = len(alist)
    # 初始步長
    gap = n / 2
    while gap > 0:
        # 按步長進行插入排序
        for i in range(gap, n):
            j = i
            # 插入排序
            while j>=gap and alist[j-gap] > alist[j]:
                alist[j-gap], alist[j] = alist[j], alist[j-gap]
                j -= gap
        # 得到新的步長
        gap = gap / 2

2. 時間複雜度

（1）最優時間複雜度：根據步長序列的不同而不同

（2）最壞時間複雜度：O（n²）

（3）穩定性：不穩定

六. 歸併排序

歸併排序是採用分治法（把複雜問題分解為相對簡單的子問題，分別求解，最後通過組合起子問題的解的方式得到原問題的解）的一個非常典型的應用。歸併排序的思想就是先遞迴分解陣列，再合併陣列

將陣列分解最小之後，然後合併兩個有序陣列，基本思路是比較兩個陣列的最前面的數，水小九先取誰，取了後相應的指標就往後移一位。然後比較，直至一個數組為空，最後把另一個數組的剩餘部分複製過來即可

1. 歸併排序分析

程式碼實現：

def merge_sort(alist):
    if len(alist) <= 1:
        return alist
    # 二分分解
    num = len(alist)/2
    left = merge_sort(alist[:num])
    right = merge_sort(alist[num:])
    # 合併
    return merge(left,right)

def merge(left, right):
    '''合併操作，將兩個有序陣列left[]和right[]合併成一個大的有序陣列'''
    #left與right的下標指標
    l, r = 0, 0
    result = []
    while l<len(left) and r<len(right):
        if left[l] < right[r]:
            result.append(left[l])
            l += 1
        else:
            result.append(right[r])
            r += 1
    result += left[l:]
    result += right[r:]
    return result

2.時間複雜度

（1）最優時間複雜度：O(nlogn)

（2）最壞時間複雜度：O(nlogn)

（3）穩定性：穩定