1、冒泡排序
（英語：Bubble Sort）是一種簡單的排序算法。它重復地遍歷要排序的數列，一次比較兩個元素，如果他們的順序錯誤就把他們交換過來。遍歷數列的工作是重復地進行直到沒有再需要交換，也就是說該數列已經排序完成。這個算法的名字由來是因為越小的元素會經由交換慢慢“浮”到數列的頂端。
冒泡排序算法的運作如下：
- 比較相鄰的元素。如果第一個比第二個大（升序），就交換他們兩個。
- 對每一對相鄰元素作同樣的工作，從開始第一對到結尾的最后一對。這步做完后，最后的元素會是最大的數。
- 針對所有的元素重復以上的步驟，除了最后一個。
- 持續每次對越來越少的元素重復上面的步驟，直到沒有任何一對數字需要比較。
# 冒泡排序穩定 def bubble_sort(alist): for i in range(len(alist)): for j in range(i, len(alist)): # 如果比i位置的小，則與i位置更換位置 if alist[i] > alist[j]: alist[i], alist[j] = alist[j], alist[i] return alist li = [54, 26, 93, 17, 77, 31, 44, 55, 20] bubble_sort(li) print(li)
時間復雜度
- 最優時間復雜度：O(n) （表示遍歷一次發現沒有任何可以交換的元素，排序結束。）
- 最壞時間復雜度：O(n2)
- 穩定性：穩定
冒泡排序的演示
2、選擇排序
選擇排序（Selection sort）是一種簡單直觀的排序算法。它的工作原理如下。首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再從剩余未排序元素中繼續尋找最小（大）元素，然后放到已排序序列的末尾。以此類推，直到所有元素均排序完畢。
選擇排序的主要優點與數據移動有關。如果某個元素位於正確的最終位置上，則它不會被移動。選擇排序每次交換一對元素，它們當中至少有一個將被移到其最終位置上，因此對n個元素的表進行排序總共進行至多n-1次交換。在所有的完全依靠交換去移動元素的排序方法中，選擇排序屬於非常好的一種。
# 選擇排序 def select_sort(alist): # 需要進行len(alist)-1次選擇操作 for i in range(len(alist) - 1): # 記錄最小位置 min_index = i # 從i+1位置到末尾選擇出最小數據 for j in range(i + 1, len(alist)): # 如果選擇的數據比當前最小值小，則記錄最小值的新位置 if alist[min_index] > alist[j]: min_index = j # 如果選擇出的數據不在正確位置，進行交換 if min_index != i: alist[i], alist[min_index] = alist[min_index], alist[i] min_index += 1 alist = [54,226,93,17,77,31,44,55,20] select_sort(alist) print(alist)
時間復雜度
- 最優時間復雜度：O(n2)
- 最壞時間復雜度：O(n2)
- 穩定性：不穩定（考慮升序每次選擇最大的情況）
選擇排序演示
3、插入排序
插入排序（英語：Insertion Sort）是一種簡單直觀的排序算法。它的工作原理是通過構建有序序列，對於未排序數據，在已排序序列中從后向前掃描，找到相應位置並插入。插入排序在實現上，在從后向前掃描過程中，需要反復把已排序元素逐步向后挪位，為最新元素提供插入空間。
時間復雜度
- 最優時間復雜度：O(n) （升序排列，序列已經處於升序狀態）
- 最壞時間復雜度：O(n2)
- 穩定性：穩定
# 插入排序 def insert_sort(alist): for i in range(1,len(alist)): # 從第二個位置，即下標為1的元素開始向前面的有序數列插入 for j in range(i, 0, -1): # 反向循環前面的有序數列， # 從第i個元素開始向前比較，如果小於前一個元素，交換位置 if alist[j] < alist[j - 1]: alist[j], alist[j - 1] = alist[j - 1], alist[j] alist = [54,26,93,17,77,31,44,55,20] insert_sort(alist) print(alist)
插入排序演示
4、快速排序
快速排序（英語：Quicksort），又稱划分交換排序（partition-exchange sort），通過一趟排序將要排序的數據分割成獨立的兩部分，其中一部分的所有數據都比另外一部分的所有數據都要小，然后再按此方法對這兩部分數據分別進行快速排序，整個排序過程可以遞歸進行，以此達到整個數據變成有序序列。
步驟為：
- 從數列中挑出一個元素，稱為"基准"（pivot），
- 重新排序數列，所有元素比基准值小的擺放在基准前面，所有元素比基准值大的擺在基准的后面（相同的數可以到任一邊）。在這個分區結束之后，該基准就處於數列的中間位置。這個稱為分區（partition）操作。
- 遞歸地（recursive）把小於基准值元素的子數列和大於基准值元素的子數列排序。
遞歸的最底部情形，是數列的大小是零或一，也就是永遠都已經被排序好了。雖然一直遞歸下去，但是這個算法總會結束，因為在每次的迭代（iteration）中，它至少會把一個元素擺到它最后的位置去。
# 快速排序(1) def quick_sort(alist): if len(alist) < 2: return alist pivot = alist[len(alist) // 2] left_alist, right_alist = [], [] alist.remove(pivot) for i in alist: left_alist.append(i) if i < pivot else right_alist.append(i) return quick_sort(left_alist) + [pivot] + quick_sort(right_alist) alist = [54, 26, 93, 17, 77, 31, 44, 55, 20] print(quick_sort(alist)) # 快速排序(2) def quick_sort(alist, first, last): if first >= last: return min_value = alist[first] low = first high = last while low < high: # high左移 while low < high and alist[high] >= min_value: high -= 1 alist[low] = alist[high] # low右移 while low < high and alist[low] < min_value: low += 1 alist[high] = alist[low] alist[low] = min_value quick_sort(alist, first, low - 1) quick_sort(alist, low + 1, last) if __name__ == '__main__': alist = [54, 26, 93, 17, 77, 31, 44, 55, 20] quick_sort(alist, 0, len(alist) - 1) print(alist)
時間復雜度
- 最優時間復雜度：O(nlogn)
- 最壞時間復雜度：O(n2)
- 穩定性：不穩定
從一開始快速排序平均需要花費O(n log n)時間的描述並不明顯。但是不難觀察到的是分區運算，數組的元素都會在每次循環中走訪過一次，使用O(n)的時間。在使用結合（concatenation）的版本中，這項運算也是O(n)。
在最好的情況，每次我們運行一次分區，我們會把一個數列分為兩個幾近相等的片段。這個意思就是每次遞歸調用處理一半大小的數列。因此，在到達大小為一的數列前，我們只要作log n次嵌套的調用。這個意思就是調用樹的深度是O(log n)。但是在同一層次結構的兩個程序調用中，不會處理到原來數列的相同部分；因此，程序調用的每一層次結構總共全部僅需要O(n)的時間（每個調用有某些共同的額外耗費，但是因為在每一層次結構僅僅只有O(n)個調用，這些被歸納在O(n)系數中）。結果是這個算法僅需使用O(n log n)時間。
5、歸並排序
歸並排序是采用分治法的一個非常典型的應用。歸並排序的思想就是先遞歸分解數組，再合並數組。
將數組分解最小之后，然后合並兩個有序數組，基本思路是比較兩個數組的最前面的數，誰小就先取誰，取了后相應的指針就往后移一位。然后再比較，直至一個數組為空，最后把另一個數組的剩余部分復制過來即可。
歸並
# coding:utf-8 def merge_sort(alist): n = len(alist) if n <= 1: print(alist) return alist mid = n // 2 # left 采用歸並排序后形成的新的列表 print(alist[:mid]) left_li = merge_sort(alist[:mid]) # right 采用歸並排序后形成的新的列表 right_li = merge_sort(alist[mid:]) # 將兩個有序的子系列合並成一個新的整體 # merge(left,right) left_pointer, right_pointer = 0, 0 result = [] while left_pointer < len(left_li) and right_pointer < len(right_li): if left_li[left_pointer] < right_li[right_pointer]: result.append(left_li[left_pointer]) left_pointer += 1 else: result.append(right_li[right_pointer]) right_pointer += 1 result += left_li[left_pointer:] result += right_li[right_pointer:] return result if __name__ == '__main__': alist = [54, 26, 93, 17, 77, 31, 44, 55, 20] print(alist) print(merge_sort(alist)) # 邏輯順序 # merge_sort [54, 26, 93, 17, 77, 31, 44, 55, 20] # # left_li = merge_sort [54, 26, 93, 17] # # left_li = merge_sort [54, 26] # left_li = [26, 54] # # # left_li = [54] # right_li = [26] # result = [26, 54] # return result # # right_li = merge_sort([93, 17]) # # left_li = merge_sort([93]) # # return [93] # left_li =[93] # # right_li = merge_sort([17]) # # return [17] # right_li = [17] # # result = [17, 93] # # return result # # right_li = [17, 93] # # result = [17, 26, 54, 93] # # return result # # left_li = [17, 26, 54, 93] # # right_li = merge_sort([77, 31, 44, 55, 20]) # # # result = [] # return result
時間復雜度
- 最優時間復雜度：O(nlogn)
- 最壞時間復雜度：O(nlogn)
- 穩定性：穩定