python 十大經典排序算法

時間 2019-11-08

原文原文鏈接

排序算法能夠分爲內部排序和外部排序，內部排序是數據記錄在內存中進行排序，而外部排序是因排序的數據很大，一次不能容納所有的排序記錄，在排序過程當中須要訪問外存。常見的內部排序算法有：插入排序、希爾排序、選擇排序、冒泡排序、歸併排序、快速排序、堆排序、基數排序等。用一張圖歸納：web

關於時間複雜度：算法

平方階 (O(n2)) 排序各種簡單排序：直接插入、直接選擇和冒泡排序。shell
線性對數階 (O(nlog2n)) 排序快速排序、堆排序和歸併排序。api
O(n1+§)) 排序，§ 是介於 0 和 1 之間的常數。希爾排序。數組
線性階 (O(n)) 排序基數排序，此外還有桶、箱排序。數據結構

關於穩定性：架構

穩定的排序算法：冒泡排序、插入排序、歸併排序和基數排序。app

不是穩定的排序算法：選擇排序、快速排序、希爾排序、堆排序。ide

名詞解釋：函數

n：數據規模

k：「桶」的個數

In-place：佔用常數內存，不佔用額外內存

Out-place：佔用額外內存

穩定性：排序後 2 個相等鍵值的順序和排序以前它們的順序相同

冒泡排序

冒泡排序（Bubble Sort）也是一種簡單直觀的排序算法。它重複地走訪過要排序的數列，一次比較兩個元素，若是他們的順序錯誤就把他們交換過來。走訪數列的工做是重複地進行直到沒有再須要交換，也就是說該數列已經排序完成。這個算法的名字由來是由於越小的元素會經由交換慢慢「浮」到數列的頂端。

做爲最簡單的排序算法之一，冒泡排序給個人感受就像 Abandon 在單詞書裏出現的感受同樣，每次都在第一頁第一位，因此最熟悉。冒泡排序還有一種優化算法，就是立一個 flag，當在一趟序列遍歷中元素沒有發生交換，則證實該序列已經有序。但這種改進對於提高性能來講並無什麼太大做用。

1. 算法步驟

比較相鄰的元素。若是第一個比第二個大，就交換他們兩個。
對每一對相鄰元素做一樣的工做，從開始第一對到結尾的最後一對。這步作完後，最後的元素會是最大的數。
針對全部的元素重複以上的步驟，除了最後一個。
持續每次對愈來愈少的元素重複上面的步驟，直到沒有任何一對數字須要比較。

2. 動圖演示

3. Python 代碼實現
```
def bubbleSort(arr):
    for i in range(1, len(arr)):
        for j in range(0, len(arr)-i):
            if arr[j] > arr[j+1]:
                arr[j], arr[j + 1] = arr[j + 1], arr[j]
    return arr
```
選擇排序

選擇排序是一種簡單直觀的排序算法，不管什麼數據進去都是 O(n²) 的時間複雜度。因此用到它的時候，數據規模越小越好。惟一的好處可能就是不佔用額外的內存空間了吧。

1. 算法步驟
1. 首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置
2. 再從剩餘未排序元素中繼續尋找最小（大）元素，而後放到已排序序列的末尾。
3. 重複第二步，直到全部元素均排序完畢。
2. 動圖演示

3. Python 代碼實現
```
def selectionSort(arr):
    for i in range(len(arr) - 1):
        # 記錄最小數的索引
        minIndex = i
        for j in range(i + 1, len(arr)):
            if arr[j] < arr[minIndex]:
                minIndex = j
        # i 不是最小數時，將 i 和最小數進行交換
        if i != minIndex:
            arr[i], arr[minIndex] = arr[minIndex], arr[i]
    return arr
```
插入排序

插入排序的代碼實現雖然沒有冒泡排序和選擇排序那麼簡單粗暴，但它的原理應該是最容易理解的了，由於只要打過撲克牌的人都應該可以秒懂。插入排序是一種最簡單直觀的排序算法，它的工做原理是經過構建有序序列，對於未排序數據，在已排序序列中從後向前掃描，找到相應位置並插入。

插入排序和冒泡排序同樣，也有一種優化算法，叫作拆半插入。

1. 算法步驟
1. 將第一待排序序列第一個元素看作一個有序序列，把第二個元素到最後一個元素當成是未排序序列。
2. 從頭至尾依次掃描未排序序列，將掃描到的每一個元素插入有序序列的適當位置。（若是待插入的元素與有序序列中的某個元素相等，則將待插入元素插入到相等元素的後面。）
2. 動圖演示

3. Python 代碼實現
```
def insertionSort(arr):
    for i in range(len(arr)):
        preIndex = i-1
        current = arr[i]
        while preIndex >= 0 and arr[preIndex] > current:
            arr[preIndex+1] = arr[preIndex]
            preIndex-=1
        arr[preIndex+1] = current
    return arr
```
希爾排序

希爾排序，也稱遞減增量排序算法，是插入排序的一種更高效的改進版本。但希爾排序是非穩定排序算法。

希爾排序是基於插入排序的如下兩點性質而提出改進方法的：
- 插入排序在對幾乎已經排好序的數據操做時，效率高，便可以達到線性排序的效率；
- 但插入排序通常來講是低效的，由於插入排序每次只能將數據移動一位；
希爾排序的基本思想是：先將整個待排序的記錄序列分割成爲若干子序列分別進行直接插入排序，待整個序列中的記錄「基本有序」時，再對全體記錄進行依次直接插入排序。

1. 算法步驟
1. 選擇一個增量序列 t1，t2，……，tk，其中 ti > tj, tk = 1；
2. 按增量序列個數 k，對序列進行 k 趟排序；
3. 每趟排序，根據對應的增量 ti，將待排序列分割成若干長度爲 m 的子序列，分別對各子表進行直接插入排序。僅增量因子爲 1 時，整個序列做爲一個表來處理，表長度即爲整個序列的長度。
2. Python 代碼實現
```
def shellSort(arr):
    import math
    gap=1
    while(gap < len(arr)/3):
        gap = gap*3+1
    while gap > 0:
        for i in range(gap,len(arr)):
            temp = arr[i]
            j = i-gap
            while j >=0 and arr[j] > temp:
                arr[j+gap]=arr[j]
                j-=gap
            arr[j+gap] = temp
        gap = math.floor(gap/3)
    return arr
```
歸併排序

歸併排序（Merge sort）是創建在歸併操做上的一種有效的排序算法。該算法是採用分治法（Divide and Conquer）的一個很是典型的應用。

做爲一種典型的分而治之思想的算法應用，歸併排序的實現由兩種方法：
- 自上而下的遞歸（全部遞歸的方法均可以用迭代重寫，因此就有了第 2 種方法）；
- 自下而上的迭代；
在《數據結構與算法 JavaScript 描述》中，做者給出了自下而上的迭代方法。可是對於遞歸法，做者卻認爲：

However, it is not possible to do so in JavaScript, as the recursion goes too deep for the language to handle.

然而，在 JavaScript 中這種方式不太可行，由於這個算法的遞歸深度對它來說太深了。

說實話，我不太理解這句話。意思是 JavaScript 編譯器內存過小，遞歸太深容易形成內存溢出嗎？還望有大神可以指教。

和選擇排序同樣，歸併排序的性能不受輸入數據的影響，但表現比選擇排序好的多，由於始終都是 O(nlogn) 的時間複雜度。代價是須要額外的內存空間。

1. 算法步驟
1. 申請空間，使其大小爲兩個已經排序序列之和，該空間用來存放合併後的序列；
2. 設定兩個指針，最初位置分別爲兩個已經排序序列的起始位置；
3. 比較兩個指針所指向的元素，選擇相對小的元素放入到合併空間，並移動指針到下一位置；
4. 重複步驟 3 直到某一指針達到序列尾；
5. 將另外一序列剩下的全部元素直接複製到合併序列尾。
2. 動圖演示

3. Python 代碼實現
```
def mergeSort(arr):
    import math
    if(len(arr)<2):
        return arr
    middle = math.floor(len(arr)/2)
    left, right = arr[0:middle], arr[middle:]
    return merge(mergeSort(left), mergeSort(right))

def merge(left,right):
    result = []
    while left and right:
        if left[0] <= right[0]:
            result.append(left.pop(0));
        else:
            result.append(right.pop(0));
    while left:
        result.append(left.pop(0));
    while right:
        result.append(right.pop(0));
    return result
```
快速排序

快速排序是由東尼·霍爾所發展的一種排序算法。在平均情況下，排序 n 個項目要 Ο(nlogn) 次比較。在最壞情況下則須要 Ο(n2) 次比較，但這種情況並不常見。事實上，快速排序一般明顯比其餘 Ο(nlogn) 算法更快，由於它的內部循環（inner loop）能夠在大部分的架構上頗有效率地被實現出來。

快速排序使用分治法（Divide and conquer）策略來把一個串行（list）分爲兩個子串行（sub-lists）。

快速排序又是一種分而治之思想在排序算法上的典型應用。本質上來看，快速排序應該算是在冒泡排序基礎上的遞歸分治法。

快速排序的名字起的是簡單粗暴，由於一聽到這個名字你就知道它存在的意義，就是快，並且效率高！它是處理大數據最快的排序算法之一了。雖然 Worst Case 的時間複雜度達到了 O(n²)，可是人家就是優秀，在大多數狀況下都比平均時間複雜度爲 O(n logn) 的排序算法表現要更好，但是這是爲何呢，我也不知道。好在個人強迫症又犯了，查了 N 多資料終於在《算法藝術與信息學競賽》上找到了滿意的答案：

快速排序的最壞運行狀況是 O(n²)，好比說順序數列的快排。但它的平攤指望時間是 O(nlogn)，且 O(nlogn) 記號中隱含的常數因子很小，比複雜度穩定等於 O(nlogn) 的歸併排序要小不少。因此，對絕大多數順序性較弱的隨機數列而言，快速排序老是優於歸併排序。

1. 算法步驟
1. 從數列中挑出一個元素，稱爲「基準」（pivot）;
2. 從新排序數列，全部元素比基準值小的擺放在基準前面，全部元素比基準值大的擺在基準的後面（相同的數能夠到任一邊）。在這個分區退出以後，該基準就處於數列的中間位置。這個稱爲分區（partition）操做；
3. 遞歸地（recursive）把小於基準值元素的子數列和大於基準值元素的子數列排序；
遞歸的最底部情形，是數列的大小是零或一，也就是永遠都已經被排序好了。雖然一直遞歸下去，可是這個算法總會退出，由於在每次的迭代（iteration）中，它至少會把一個元素擺到它最後的位置去。

2. 動圖演示

3. Python 代碼實現
```
def quickSort(arr, left=None, right=None):
    left = 0 if not isinstance(left,(int, float)) else left
    right = len(arr)-1 if not isinstance(right,(int, float)) else right
    if left < right:
        partitionIndex = partition(arr, left, right)
        quickSort(arr, left, partitionIndex-1)
        quickSort(arr, partitionIndex+1, right)
    return arr

def partition(arr, left, right):
    pivot = left
    index = pivot+1
    i = index
    while  i <= right:
        if arr[i] < arr[pivot]:
            swap(arr, i, index)
            index+=1
        i+=1
    swap(arr,pivot,index-1)
    return index-1

def swap(arr, i, j):
    arr[i], arr[j] = arr[j], arr[i]
```
堆排序

堆排序（Heapsort）是指利用堆這種數據結構所設計的一種排序算法。堆積是一個近似徹底二叉樹的結構，並同時知足堆積的性質：即子結點的鍵值或索引老是小於（或者大於）它的父節點。堆排序能夠說是一種利用堆的概念來排序的選擇排序。分爲兩種方法：
1. 大頂堆：每一個節點的值都大於或等於其子節點的值，在堆排序算法中用於升序排列；
2. 小頂堆：每一個節點的值都小於或等於其子節點的值，在堆排序算法中用於降序排列；
堆排序的平均時間複雜度爲 Ο(nlogn)。

1. 算法步驟
1. 建立一個堆 H[0……n-1]；
2. 把堆首（最大值）和堆尾互換；
3. 把堆的尺寸縮小 1，並調用 shift_down(0)，目的是把新的數組頂端數據調整到相應位置；
4. 重複步驟 2，直到堆的尺寸爲 1。
2. 動圖演示

3. Python 代碼實現
```
def buildMaxHeap(arr):
    import math
    for i in range(math.floor(len(arr)/2),-1,-1):
        heapify(arr,i)

def heapify(arr, i):
    left = 2*i+1
    right = 2*i+2
    largest = i
    if left < arrLen and arr[left] > arr[largest]:
        largest = left
    if right < arrLen and arr[right] > arr[largest]:
        largest = right

    if largest != i:
        swap(arr, i, largest)
        heapify(arr, largest)

def swap(arr, i, j):
    arr[i], arr[j] = arr[j], arr[i]

def heapSort(arr):
    global arrLen
    arrLen = len(arr)
    buildMaxHeap(arr)
    for i in range(len(arr)-1,0,-1):
        swap(arr,0,i)
        arrLen -=1
        heapify(arr, 0)
    return arr
```
計數排序

計數排序的核心在於將輸入的數據值轉化爲鍵存儲在額外開闢的數組空間中。做爲一種線性時間複雜度的排序，計數排序要求輸入的數據必須是有肯定範圍的整數。

1. 動圖演示

2. Python 代碼實現
```
def countingSort(arr, maxValue):
    bucketLen = maxValue+1
    bucket = [0]*bucketLen
    sortedIndex =0
    arrLen = len(arr)
    for i in range(arrLen):
        if not bucket[arr[i]]:
            bucket[arr[i]]=0
        bucket[arr[i]]+=1
    for j in range(bucketLen):
        while bucket[j]>0:
            arr[sortedIndex] = j
            sortedIndex+=1
            bucket[j]-=1
    return arr
```
桶排序

桶排序是計數排序的升級版。它利用了函數的映射關係，高效與否的關鍵就在於這個映射函數的肯定。爲了使桶排序更加高效，咱們須要作到這兩點：
1. 在額外空間充足的狀況下，儘可能增大桶的數量
2. 使用的映射函數可以將輸入的 N 個數據均勻的分配到 K 個桶中
同時，對於桶中元素的排序，選擇何種比較排序算法對於性能的影響相當重要。

1. 何時最快

當輸入的數據能夠均勻的分配到每個桶中。

2. 何時最慢

當輸入的數據被分配到了同一個桶中。

基數排序

基數排序是一種非比較型整數排序算法，其原理是將整數按位數切割成不一樣的數字，而後按每一個位數分別比較。因爲整數也能夠表達字符串（好比名字或日期）和特定格式的浮點數，因此基數排序也不是隻能使用於整數。

1. 基數排序 vs 計數排序 vs 桶排序

基數排序有兩種方法：

這三種排序算法都利用了桶的概念，但對桶的使用方法上有明顯差別：
- 基數排序：根據鍵值的每位數字來分配桶；
- 計數排序：每一個桶只存儲單一鍵值；
- 桶排序：每一個桶存儲必定範圍的數值；
2. LSD 基數排序動圖演示