排序算法
冒泡排序
選擇排序
插入排序
快速排序（最常見）
希爾排序
歸并排序
源碼：Sorting
冒泡排序
冒泡排序（Bubble Sort）是一種簡單的排序算法。它重復地遍歷要排序的數列，一次比較兩個元素，如果他們的順序錯誤就把他們交換過來。遍歷數列的工作是重復地進行直到沒有再需要交換，也就是說該數列已經排序完成。這個算法的名字由來是因為越小的元素會經由交換慢慢“浮”到數列的頂端。
-
冒泡排序算法的思路如下（升序）：
- 比較相鄰的元素。如果第一個比第二個大，就交換他們兩個。
- 對每一對相鄰元素作同樣的工作，從開始第一對到結尾的最后一對。這步做完后，最后的元素會是最大的數。
- 針對所有的元素重復以上的步驟，除了最后一個。
- 持續每次對越來越少的元素重復上面的步驟，直到沒有任何一對數字需要比較。
-
冒泡排序的分析
bubblesort -
演示
bubble -
時間復雜度
- 最優時間復雜度：O(n) ——表示遍歷一次發現沒有任何可以交換的元素，排序結束
- 最壞時間復雜度：O(n2)
- 穩定性：穩定
-
Python 代碼
def bubble_sort(L): N = len(L) if N <= 0 : print("Please input correct list.") return for i in range(N): for j in range(0,N-1-i): if L[j] > L[j+1] : L[j],L[j+1] = L[j+1],L[j] print(L) return L if __name__ == '__main__': L = [9,8,7,6,5,4,3,2,1] print(bubble_sort(L)) -
輸出
>>> RESTART: F:\雜\markdown\Python\DataStructure&Algorithm\Sorting\bubble_sort.py [8, 9, 7, 6, 5, 4, 3, 2, 1] [8, 7, 9, 6, 5, 4, 3, 2, 1] [8, 7, 6, 9, 5, 4, 3, 2, 1] [8, 7, 6, 5, 9, 4, 3, 2, 1] [8, 7, 6, 5, 4, 9, 3, 2, 1] [8, 7, 6, 5, 4, 3, 9, 2, 1] [8, 7, 6, 5, 4, 3, 2, 9, 1] [8, 7, 6, 5, 4, 3, 2, 1, 9] [7, 8, 6, 5, 4, 3, 2, 1, 9] [7, 6, 8, 5, 4, 3, 2, 1, 9] [7, 6, 5, 8, 4, 3, 2, 1, 9] [7, 6, 5, 4, 8, 3, 2, 1, 9] [7, 6, 5, 4, 3, 8, 2, 1, 9] [7, 6, 5, 4, 3, 2, 8, 1, 9] [7, 6, 5, 4, 3, 2, 1, 8, 9] [6, 7, 5, 4, 3, 2, 1, 8, 9] [6, 5, 7, 4, 3, 2, 1, 8, 9] [6, 5, 4, 7, 3, 2, 1, 8, 9] [6, 5, 4, 3, 7, 2, 1, 8, 9] [6, 5, 4, 3, 2, 7, 1, 8, 9] [6, 5, 4, 3, 2, 1, 7, 8, 9] [5, 6, 4, 3, 2, 1, 7, 8, 9] [5, 4, 6, 3, 2, 1, 7, 8, 9] [5, 4, 3, 6, 2, 1, 7, 8, 9] [5, 4, 3, 2, 6, 1, 7, 8, 9] [5, 4, 3, 2, 1, 6, 7, 8, 9] [4, 5, 3, 2, 1, 6, 7, 8, 9] [4, 3, 5, 2, 1, 6, 7, 8, 9] [4, 3, 2, 5, 1, 6, 7, 8, 9] [4, 3, 2, 1, 5, 6, 7, 8, 9] [3, 4, 2, 1, 5, 6, 7, 8, 9] [3, 2, 4, 1, 5, 6, 7, 8, 9] [3, 2, 1, 4, 5, 6, 7, 8, 9] [2, 3, 1, 4, 5, 6, 7, 8, 9] [2, 1, 3, 4, 5, 6, 7, 8, 9] [1, 2, 3, 4, 5, 6, 7, 8, 9] [1, 2, 3, 4, 5, 6, 7, 8, 9] >>>
選擇排序
選擇排序（Selection sort）是一種簡單直觀的排序算法。
-
它的工作原理如下：
- 首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置
- 然后，再從剩余未排序元素中繼續尋找最小（大）元素，然后放到已排序序列的末尾
- 以此類推，直到所有元素均排序完畢。
選擇排序的主要優點與數據移動有關。如果某個元素位于正確的最終位置上，則它不會被移動。選擇排序每次交換一對元素，它們當中至少有一個將被移到其最終位置上，因此對n個元素的表進行排序總共進行至多n-1次交換。在所有的完全依靠交換去移動元素的排序方法中，選擇排序屬于非常好的一種。
-
選擇排序分析
selectionsort -
演示
selection -
時間復雜度
- 最優時間復雜度：O(n2)
- 最壞時間復雜度：O(n2)
- 穩定性：不穩定（考慮升序每次選擇最大的情況）
-
Python 代碼
def select_sort(L): N = len(L) if N <= 0 : print("Please input correct list.") return for i in range(N-1): indexOfMax = 0 for j in range(1,N-i): if L[j] > L[indexOfMax] : indexOfMax = j L[N-1-i], L[indexOfMax] = L[indexOfMax], L[N-1-i] print(L) return L if __name__ == '__main__': L = [9,8,7,6,5,4,3,2,1] select_sort(L) -
輸出
>>> RESTART: F:/雜/markdown/Python/DataStructure&Algorithm/Sorting/selection_sort.py [1, 8, 7, 6, 5, 4, 3, 2, 9] [1, 2, 7, 6, 5, 4, 3, 8, 9] [1, 2, 3, 6, 5, 4, 7, 8, 9] [1, 2, 3, 4, 5, 6, 7, 8, 9] [1, 2, 3, 4, 5, 6, 7, 8, 9] [1, 2, 3, 4, 5, 6, 7, 8, 9] [1, 2, 3, 4, 5, 6, 7, 8, 9] [1, 2, 3, 4, 5, 6, 7, 8, 9] >>>
插入排序
插入排序（Insertion Sort）是一種簡單直觀的排序算法，對于少量元素，它是一種有效的算法。
想像一下，我們在打撲克牌，首先我們手上沒有牌，然后一張一張從桌上摸牌，每次摸牌都會按照從小到大的順序排好，所以手上的牌總是有序的。
-
它的工作原理：
- 通過構建有序序列，對于未排序數據，在已排序序列中從后向前掃描，找到相應位置并插入。
- 插入排序在實現上，在從后向前掃描過程中，需要反復把已排序元素逐步向后挪位，為最新元素提供插入空間。
-
演示
Insertion-sort-example -
偽代碼
INSERTION-SORT(A) for j = 2 to A.length key = A[j] //Insert A[j] into the sorted sequence A[1..j-1]. i = j - 1 while i > 0 and A[i] > key A[i+1] = A[i] i = i - 1 A[i+1] = key -
時間復雜度
- 最優時間復雜度：O(n) ——升序排列，序列已經處于升序狀態
- 最壞時間復雜度：O(n2) ——序列處于降序狀態，要轉變為升序
- 穩定性：穩定
-
Python 代碼
def insertion_sort(L): N = len(L) if N <= 0: print("Please input correct list.") return for i in range(N): # i指示當前待排元素 if L[i - 1] < L[i]: # 如果待排元素比已排序列的最后一個元素（最大的元素）還大，則直接加入已排序列 continue temp = L[i] for j in range(i - 1, -1, -1): # i-1指示已排序列的最后一項，然后以此與當前待排元素比較，往前移動 L[j + 1] = L[j] if L[j - 1] <= temp: L[j] = temp print(L) break return L if __name__ == '__main__': L = [1, 8, 7, 6, 5, 4, 3, 2, 1] print("ordered sequence =",insertion_sort(L)) -
輸出
>>> RESTART: F:\雜\markdown\Python\DataStructure&Algorithm\Sorting\insertion_sort.py [8, 9, 7, 6, 5, 4, 3, 2, 1] [7, 8, 9, 6, 5, 4, 3, 2, 1] [6, 7, 8, 9, 5, 4, 3, 2, 1] [5, 6, 7, 8, 9, 4, 3, 2, 1] [4, 5, 6, 7, 8, 9, 3, 2, 1] [3, 4, 5, 6, 7, 8, 9, 2, 1] [2, 3, 4, 5, 6, 7, 8, 9, 1] [1, 2, 3, 4, 5, 6, 7, 8, 9] [1, 2, 3, 4, 5, 6, 7, 8, 9] >>>
快速排序（最常見）
快速排序（英語：Quicksort），又稱劃分交換排序（partition-exchange sort），通過一趟排序將要排序的數據分割成獨立的兩部分，其中一部分的所有數據都比另外一部分的所有數據都要小，然后再按此方法對這兩部分數據分別進行快速排序，整個排序過程可以遞歸進行，以此達到整個數據變成有序序列。
-
步驟為：
- 從數列中挑出一個元素，稱為"基準"（pivot），或稱樞紐
- 重新排序數列，所有元素比基準值小的擺放在基準前面，所有元素比基準值大的擺在基準的后面（相同的數可以到任一邊）。在這個分區結束之后，該基準就處于數列的中間位置。這個稱為分區（partition）操作。
- 遞歸地（recursive）把小于基準值元素的子數列和大于基準值元素的子數列排序。
- 遞歸的最底部情形，是數列的大小是零或一，也就是永遠都已經被排序好了。雖然一直遞歸下去，但是這個算法總會結束，因為在每次的迭代（iteration）中，它至少會把一個元素擺到它最后的位置去。
-
時間復雜度
- 最優時間復雜度：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)時間。
-
Python 代碼
def quick_sort(L): return qsort(L,0,len(L)-1) def qsort(L,low,high): if(low < high): pivotloc = partition(L,low,high) qsort(L,low,pivotloc-1) qsort(L,pivotloc+1,high) return L def partition(L,low,high): if(low >= high): return pivotkey = L[low] while(low < high): while(low < high and L[high] >= pivotkey): high = high - 1 L[low],L[high] = L[high],L[low] while(low < high and L[low] <= pivotkey): low = low + 1 L[high],L[low] = L[low],L[high] print("pivotkey =",pivotkey) print(L,"\n") return low if __name__ == '__main__': L = [9,8,7,6,5,4,3,2,1] print(quick_sort(L)) -
輸出
>>> RESTART: F:\雜\markdown\Python\DataStructure&Algorithm\Sorting\quick_sort.py pivotkey = 9 [1, 8, 7, 6, 5, 4, 3, 2, 9] pivotkey = 1 [1, 8, 7, 6, 5, 4, 3, 2, 9] pivotkey = 8 [1, 2, 7, 6, 5, 4, 3, 8, 9] pivotkey = 2 [1, 2, 7, 6, 5, 4, 3, 8, 9] pivotkey = 7 [1, 2, 3, 6, 5, 4, 7, 8, 9] pivotkey = 3 [1, 2, 3, 6, 5, 4, 7, 8, 9] pivotkey = 6 [1, 2, 3, 4, 5, 6, 7, 8, 9] pivotkey = 4 [1, 2, 3, 4, 5, 6, 7, 8, 9] [1, 2, 3, 4, 5, 6, 7, 8, 9] >>>
希爾排序
希爾排序(Shell Sort)是插入排序的一種。也稱縮小增量排序，是直接插入排序算法的一種更高效的改進版本。希爾排序是非穩定排序算法。該方法因DL．Shell于1959年提出而得名。 希爾排序是把記錄按下標的一定增量分組，對每組使用直接插入排序算法排序；隨著增量逐漸減少，每組包含的關鍵詞越來越多，當增量減至1時，整個文件恰被分成一組，算法便終止。
基本思想：先將整個待排序列分割稱為若干子序列分別進行直接插入排序，待整個序列“基本有序”時，再對全體記錄進行一次直接插入排序
-
希爾排序過程
希爾排序的基本思想是：將數組列在一個表中并對列分別進行插入排序，重復這過程，不過每次用更長的列（步長更長了，列數更少了）來進行。最后整個表就只有一列了。將數組轉換至表是為了更好地理解這算法，算法本身還是使用數組進行排序。
-
例如，假設有這樣一組數[ 13 14 94 33 82 25 59 94 65 23 45 27 73 25 39 10 ]，如果我們以步長為5開始進行排序，我們可以通過將這列表放在有5列的表中來更好地描述算法，這樣他們就應該看起來是這樣(豎著的元素是步長組成)：
13 14 94 33 82 25 59 94 65 23 45 27 73 25 39 10然后我們對每列進行排序：
10 14 73 25 23 13 27 94 33 39 25 59 94 65 82 45將上述四行數字，依序接在一起時我們得到：[ 10 14 73 25 23 13 27 94 33 39 25 59 94 65 82 45 ]。這時10已經移至正確位置了，然后再以3為步長進行排序：
10 14 73 25 23 13 27 94 33 39 25 59 94 65 82 45排序之后變為：
10 14 13 25 23 33 27 25 59 39 65 73 45 94 82 94最后以1步長進行排序（此時就是簡單的插入排序了）
-
時間復雜度
- 最優時間復雜度：根據步長序列的不同而不同
- 最壞時間復雜度：O(n2)
- 穩定性：不穩定
-
Python 代碼
def shell_sort(L,delta): N = len(L) for inc in delta: L = shell_insert(L,inc) print(L,"\n") return L def shell_insert(L,inc): N = len(L) for index in range(inc): # 整個序列分為若干子序列，index是每個子序列的頭元素 for i in range(index+inc,N,inc): # 默認每個子序列的頭元素為“已排序列”，除了頭元素的子序列為“待排序列” temp = L[i] # 每個子序列的排序方式為直接插入排序，所以當前待排元素的值給temp for j in range(i-inc,-1,-inc): # 在子序列的“已排序列”中找到合適的插入地點，所以是倒序 if temp < L[j]: L[j+inc] = L[j] else : break # 當前待排元素比“已排序列”中的末尾元素還要大，所以直接放入末尾 if j == index or L[j-inc] < temp : L[j] = temp print(L) return L if __name__ == '__main__': L = [9,8,7,6,5,4,3,2,1] delta = [5,3,1] #構造增量序列 print(shell_sort(L,delta)) -
輸出
>>> RESTART: F:\雜\markdown\Python\DataStructure&Algorithm\Sorting\shell_sort.py [4, 8, 7, 6, 5, 9, 3, 2, 1] [4, 3, 7, 6, 5, 9, 8, 2, 1] [4, 3, 2, 6, 5, 9, 8, 7, 1] [4, 3, 2, 1, 5, 9, 8, 7, 6] [4, 3, 2, 1, 5, 9, 8, 7, 6] [1, 3, 2, 4, 5, 9, 8, 7, 6] [1, 3, 2, 4, 5, 6, 8, 7, 9] [1, 3, 2, 4, 5, 6, 8, 7, 9] [1, 2, 3, 4, 5, 6, 8, 7, 9] [1, 2, 3, 4, 5, 6, 7, 8, 9] [1, 2, 3, 4, 5, 6, 7, 8, 9] [1, 2, 3, 4, 5, 6, 7, 8, 9] >>>
歸并排序
歸并排序是采用分治法的一個非常典型的應用。歸并排序的思想就是先遞歸分解數組，再合并數組。
將數組分解最小之后，然后合并兩個有序數組，基本思路是比較兩個數組的最前面的數，誰小就先取誰，取了后相應的指針就往后移一位。然后再比較，直至一個數組為空，最后把另一個數組的剩余部分復制過來即可。
-
歸并排序的分析
Merge-sort-example -
時間復雜度
- 最優時間復雜度：O(nlogn)
- 最壞時間復雜度：O(nlogn)
- 穩定性：穩定
- 缺點:占用了一定的空間，所以歸并算法是用空間換取時間的典型應用
-
Python 代碼
def merge(left, right): lp, rp = 0, 0 result = [] while lp < len(left) and rp < len(right): if left[lp] <= right[rp]: result.append(left[lp]) lp += 1 else: result.append(right[rp]) rp += 1 result += left[lp:] result += right[rp:] return result def merge_sort(alist): length = len(alist) if length == 1: return alist mid = length // 2 left = merge_sort(alist[:mid]) right = merge_sort(alist[mid:]) print("left = %s, right = %s"%(left,right)) result = merge(left, right) print("merge:",result) return result if __name__ == '__main__': alist = [9, 8, 7, 6, 5, 4, 3, 2, 1] print("ordered sequence =",merge_sort(alist)) -
輸出
left = [9], right = [8] merge: [8, 9] left = [7], right = [6] merge: [6, 7] left = [8, 9], right = [6, 7] merge: [6, 7, 8, 9] left = [5], right = [4] merge: [4, 5] left = [2], right = [1] merge: [1, 2] left = [3], right = [1, 2] merge: [1, 2, 3] left = [4, 5], right = [1, 2, 3] merge: [1, 2, 3, 4, 5] left = [6, 7, 8, 9], right = [1, 2, 3, 4, 5] merge: [1, 2, 3, 4, 5, 6, 7, 8, 9] ordered sequence = [1, 2, 3, 4, 5, 6, 7, 8, 9]
各種排序算法效率比較
-
算法是否穩定：待排序列中同樣元素的先后順序是否改變
比如待排序列是：2，3，1，8，9，1'
排列后的序列是：1'，1，2，3，8，9
-
快速排序應用廣泛的原因：
性能接近 O(nlogn)
輔助空間較歸并排序小
一般不太關注穩定與否
