原文鏈接：http://note.youdao.com/noteshare?id=7b9757930ce3cc9e0a5e61e4d0aa9ea2&sub=2726FFA02ADE4E74A302D8DA7646FB46

查找算法：

二分查找法：

簡介：二分查找法又被稱為折半查找法，用於預排序的查找問題

過程：

1. 如果在列表a中查找元素t，先將列表a中間位置的項與查找關鍵字t比較，如果兩者相等，則成功。
2. 否則，將表分為前後兩個子表
3. 如果中間位置大於t，則進一步查找前一子表，否則，查找後一子表
4. 重復上述過程

優劣：

1. 時間復雜度為O(log~2~N),比較快
2. 缺點就是必須是有序列表

排序算法：

冒泡排序

簡介：兩兩比較大小，如果不滿足升序關系，則交換

過程：略

優劣：：

1. 時間復雜度為O(N^2^)，速度較慢
2. 穩定

選擇排序

簡介：找出最小值，然後放入一個新的列表中

過程：略

優劣：：

1. 時間復雜度為O(N^2^)，速度較慢
2. 穩定

插入排序法

簡介：依次檢查需要排序的列表，每次取出一個元素放入另一個排好序的列表中的適當位置。

過程：略

優劣：：

1. 時間復雜度為O(N^2^)
2. 速度不穩定，最佳情況為線性增長，最差情況為N^2^,所以速度實際上比前兩種快

歸並排序

簡介：分而制之的思想

過程：

1. 將包含N個元素的列表分為兩個含N/2元素的子列表.
2. 對兩個子列表遞歸調用歸並排序(最後將兩個子列表分解為N個子列表)。
3. 合並已排序好的列表。
4. 

優劣：：速度較快且穩定，時間復雜度為O(Nlog~2~N)

實現代碼:

def merge(left,right):
    merged = []
    i,j = 0,0
    left_len,right_len = len(left),len(right)
    while i<left_len and j<right_len:
        if left[i] <= right[j]:
            merged.append(left[i])
            i += 1
        else:
            merged.append(right[j])
            j += 1
        merged.extend(left[i:])
        merged.extend(right[j:])
        return merged

def mergeSort(a):
    if len(a) <= 1:
        return a
    else:
        mid = len(a) // 2
        left = mergeSort(a[:mid])
        right = mergeSort(a[mid:])
        merge(left,right)
        return merge(left,right)

def main():
    a = [59,12,77,64,72,69,46,89,31,9]
    a1 = mergeSort(a)
    print(a1)

if __name__ == ‘__main__‘:
    main()
 

快速排序 #：

簡介：對冒泡排序的改進

過程：

1. 設置兩個變量i和j，作為列表首末兩端的下標，即i=0，j=N-1
2. 設置列表的第一個元素作為關鍵數據，即key=A[0]
3. 從j開始向前搜索，找到第一個小於key的值A[j],將A[j]和A[i]互換
4. 從i開始向後搜索，找到第一個大於key的值A[i],將A[i]和A[j]互換
5. 重復3~4步，直到i = j

優劣：：

1. 平均情況時間復雜度為O(Nlog~2~N),比較快。
2. 最差情況下時間復雜度為O(N^2^)

Python語言中提供的排序算法

內置數據類型list的方法sort()，內置函數sorted()

這個的底層實現就是歸並排序，只是使用了Python無法編寫的底層實現，從而避免了Python本身附加的大量開銷,速度比我們自己寫的歸並排序要快很多（10~20倍）,所以說我們一般排序都盡量使用sorted和sort

Python裏面幾種排序算法的比較，sorted的底層實現，雖然我們知道sorted的實現方式，但是