幾種常見的排序算法總結（Python）
排序算法：是一種能將一串數據依照特定順序進行排序的一種算法。
穩定性：穩定排序算法會讓原本有相等鍵值的記錄維持相對次序。也就是如果一個排序算法是穩定的，當有兩個相等鍵值的記錄R和S，並且在原本列表中R出現在S之前，在排序列表中R也將是在S之前。
1. 冒泡排序
冒泡排序（英語：Bubble Sort）是一種簡單的排序算法。它重復地遍歷要排序的數列，一次比較兩個元素，如果他們的順序錯誤就把他們交換過來。遍歷數列的工作是重復地進行直到沒有再需要交換，也就是說該數列已經排序完成。這個算法的名字由來是因為越小的元素會經由交換慢慢“浮”到數列的頂端。
冒泡排序算法的運作如下：
- 比較相鄰的元素。如果第一個比第二個大（升序），就交換他們兩個。
- 對每一對相鄰元素作同樣的工作，從開始第一對到結尾的最后一對。這步做完后，最后的元素會是最大的數。
- 針對所有的元素重復以上的步驟，除了最后一個。
- 持續每次對越來越少的元素重復上面的步驟，直到沒有任何一對數字需要比較。
def bubble_sort(alist): for j in range(len(alist)-1,0,-1): # j表示每次遍歷需要比較的次數，是逐漸減小的
for i in range(j): if alist[i] > alist[i+1]: alist[i], alist[i+1] = alist[i+1], alist[i] li = [54,26,93,17,77,31,44,55,20] bubble_sort(li) print(li)
時間復雜度
最優時間復雜度：O(n)(表示遍歷一次發現沒有任何可以交換的元素，排序結束)
最壞時間復雜度：O(n^2)
穩定性：穩定
2. 選擇排序
選擇排序（Selection sort）是一種簡單直觀的排序算法。它的工作原理如下，首先在未排序的序列中找到最小（大）的元素，存放到排序序列的起始位置，然后，再從剩余未排序元素中繼續尋找最小（大）元素，然后放到已排序序列的末尾，以此類推，直到所有的元素均排序完畢。
選擇排序的主要優點與數據移動有關。如果某個元素位於正確的最終位置上，則它不會被移動。選擇排序每次交換一對元素，它們當中至少有一個將被移到其最終位置上，因此對n個元素的表進行排序總共進行至多n-1次交換。在所有的完全依靠交換去移動元素的排序方法中，選擇排序屬於非常好的一種。
def selection_sort(alist): n = len(alist) # 需要進行n-1次選擇操作
for i in range(n-1): # 記錄最小位置
min_index = i # 從i+1位置到末尾選擇出最小數據
for j in range(i+1, n): if alist[j] < alist[min_index]: min_index = j # 如果選擇出的數據不在正確位置，進行交換
if min_index != i: alist[i], alist[min_index] = alist[min_index], alist[i] alist = [54,226,93,17,77,31,44,55,20] selection_sort(alist) print(alist)
時間復雜度
最優時間復雜度：O(n^2)
最壞時間復雜度：O(n^2)
穩定性：不穩定
3. 插入排序
插入排序（英語：Insertion Sort）是一種簡單直觀的排序算法。它的工作原理是通過構建有序序列，對於未排序數據，在已排序序列中從后向前掃描，找到相應位置並插入。插入排序在實現上，在從后向前掃描過程中，需要反復把已排序元素逐步向后挪位，為最新元素提供插入空間。
def insert_sort(alist): # 從第二個位置，即下標為1的元素開始向前插入
for i in range(1, len(alist)): # 從第i個元素開始向前比較，如果小於前一個元素，交換位置
for j in range(i, 0, -1): 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)
時間復雜度
最優時間復雜度：O(n) (升序排列，序列已經處於升序狀態)
最壞時間復雜度：O(n^2)
穩定性：穩定
4. 快速排序
快速排序（英語：Quicksort），又稱划分交換排序（partition-exchange sort），通過一趟排序將要排序的數據分割成獨立的兩部分，其中一部分的所有數據都比另外一部分的所有數據都要小，然后再按此方法對這兩部分數據分別進行快速排序，整個排序過程可以遞歸進行，以此達到整個數據變成有序序列。
步驟為：
- 從數列中挑出一個元素，稱為"基准"（pivot），
- 重新排序數列，所有元素比基准值小的擺放在基准前面，所有元素比基准值大的擺在基准的后面（相同的數可以到任一邊）。在這個分區結束之后，該基准就處於數列的中間位置。這個稱為分區（partition）操作。
- 遞歸地（recursive）把小於基准值元素的子數列和大於基准值元素的子數列排序。
遞歸的最底部情形，是數列的大小是零或一，也就是永遠都已經被排序好了。雖然一直遞歸下去，但是這個算法總會結束，因為在每次的迭代（iteration）中，它至少會把一個元素擺到它最后的位置去。
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) alist = [54,26,93,17,77,31,44,55,20] quick_sort(alist,0,len(alist)-1) print(alist)
時間復雜度
最優時間復雜度：O(nlogn)
最壞時間復雜度：O(n^2)
穩定性：穩定
5. 歸並排序
歸並排序是采用分治法的一個非常典型的應用。歸並排序的思想就是先遞歸分解數組，再合並數組。將數組分解最小之后，然后合並兩個有序數組，基本思路是比較兩個數組的最前面的數，誰小就先取誰，取了后相應的指針就往后移一位。然后再比較，直至一個數組為空，最后把另一個數組的剩余部分復制過來即可。
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 alist = [54,26,93,17,77,31,44,55,20] sorted_alist = mergeSort(alist) print(sorted_alist)
時間復雜度
最優時間復雜度：O(nlogn)
最壞時間復雜度：O(nlogn)
穩定性：穩定