【排序算法】python 十大經典排序算法（全網最詳）

排序算法可以分為內部排序和外部排序，內部排序是數據記錄在內存中進行排序，而外部排序是因排序的數據很大，一次不能容納全部的排序記錄，在排序過程中需要訪問外存。常見的內部排序算法有：插入排序、希爾排序、選擇排序、冒泡排序、歸并排序、快速排序、堆排序、基數排序等。用一張圖概括：

關于穩定性：

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

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

名詞解釋：

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##################################################################list1 = [3, 6, 9, 1]def bubble(list1):for i in range(len(list1) - 1, 0, -1):  # i=3  i=2  i=1  ( n-1 ) #其實跟上邊方法一樣 for j in range(i):  # 3 0  3 1  3 2   (n-1)if list1[j] > list1[j + 1]:list1[j], list1[j + 1] = list1[j + 1], list1[j]print('---->', list1)bubble(list1)'''
時間復雜度:
O(n**2)
O(n)

?

選擇排序

選擇排序是一種簡單直觀的排序算法，無論什么數據進去都是 O(n2) 的時間復雜度。所以用到它的時候，數據規模越小越好。唯一的好處可能就是不占用額外的內存空間了吧。

1. 算法步驟

2. 動圖演示

3. Python 代碼實現

'''
選擇排序:
1. 在未排序的列表中，找出一個最大(小)值，通常找的最大值或者最小值就是列表的第一個元素位置
2. 然后在未排序的列表中依次找出最大(小)元素位置，
3. 跟假設的位置進行比較，如果原有位置與找到的最大(小)位置發生改變
4. 則進行交換'''
def selectionSort(arr):for i in range(len(arr) - 1):# 記錄最小數的索引minIndex = ifor 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. 算法步驟

2. 動圖演示

3. Python 代碼實現

'''
插入排序:
插入排序（英語：Insertion Sort）是一種簡單直觀的排序算法。它的工作原理是通過構建有序序列，
對于未排序數據，在已排序序列中從后向前掃描，找到相應位置并插入。
插入排序在實現上，在從后向前掃描過程中，需要反復把已排序元素逐步向后挪位，為最新元素提供插入空間。'''
def insertionSort(arr):for i in range(len(arr)):preIndex = i-1current = arr[i]while preIndex >= 0 and arr[preIndex] > current:arr[preIndex+1] = arr[preIndex]preIndex-=1arr[preIndex+1] = currentreturn arr#############################
#############################list1 = [3, 6, 5, 1, 9]
print('============>', list1)def insert(list1):for i in range(1, len(list1)):for j in range(i, 0, -1):if list1[j] < list1[j - 1]:list1[j], list1[j - 1] = list1[j - 1], list1[j]print('------>', list1)insert(list1)

希爾排序

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

希爾排序是基于插入排序的以下兩點性質而提出改進方法的：

希爾排序的基本思想是：先將整個待排序的記錄序列分割成為若干子序列分別進行直接插入排序，待整個序列中的記錄“基本有序”時，再對全體記錄進行依次直接插入排序。

1. 算法步驟

2. Python 代碼實現

def shellSort(arr):import mathgap=1while(gap < len(arr)/3):gap = gap*3+1while gap > 0:for i in range(gap,len(arr)):temp = arr[i]j = i-gapwhile j >=0 and arr[j] > temp:arr[j+gap]=arr[j]j-=gaparr[j+gap] = tempgap = math.floor(gap/3)return arr

歸并排序

歸并排序（Merge sort）是建立在歸并操作上的一種有效的排序算法。該算法是采用分治法（Divide and Conquer）的一個非常典型的應用。

作為一種典型的分而治之思想的算法應用，歸并排序的實現由兩種方法：

在《數據結構與算法 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. 算法步驟

2. 動圖演示

3. Python 代碼實現

def mergeSort(arr):import mathif(len(arr)<2):return arrmiddle = 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#######################################
#######################################'''
歸并排序:
歸并排序是采用分治法的一個非常典型的應用。歸并排序的思想就是先遞歸分解數組，再合并數組。將數組分解最小之后，然后合并兩個有序數組，基本思路是比較兩個數組的最前面的數，誰小就先取誰，
取了后相應的指針就往后移一位。然后再比較，直至一個數組為空，最后把另一個數組的剩余部分復制過來即可。'''
list1 = [12, 5, 7, 89]def merge_sort(list1):if len(list1) <= 1:return list1# 二分分解num = len(list1) // 2left = merge_sort(list1[:num])  # list1[:2]  12,5  2//2    --->[12]right = merge_sort(list1[num:])  # --->[5]print('--->left:', left)print('--->right:', right)return merge(left, right)def merge(left, right):l, r = 0, 0result = []while l < len(left) and r < len(right):if left[l] < right[r]:result.append(left[l])l += 1else:result.append(right[r])r += 1print('------------------------->', result)result += left[l:]            ###這里與上邊方法不太相同 不過實現效果一樣result += right[r:]return result# 調用
list1 = merge_sort(list1)print('end:', list1)

快速排序

快速排序是由東尼·霍爾所發展的一種排序算法。在平均狀況下，排序 n 個項目要 Ο(nlogn) 次比較。在最壞狀況下則需要 Ο(n2) 次比較，但這種狀況并不常見。事實上，快速排序通常明顯比其他 Ο(nlogn) 算法更快，因為它的內部循環（inner loop）可以在大部分的架構上很有效率地被實現出來。

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

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

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

快速排序的最壞運行情況是 O(n2)，比如說順序數列的快排。但它的平攤期望時間是 O(nlogn)，且 O(nlogn) 記號中隱含的常數因子很小，比復雜度穩定等于 O(nlogn) 的歸并排序要小很多。所以，對絕大多數順序性較弱的隨機數列而言，快速排序總是優于歸并排序。

1. 算法步驟

遞歸的最底部情形，是數列的大小是零或一，也就是永遠都已經被排序好了。雖然一直遞歸下去，但是這個算法總會退出，因為在每次的迭代（iteration）中，它至少會把一個元素擺到它最后的位置去。

2. 動圖演示

首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置
再從剩余未排序元素中繼續尋找最小（大）元素，然后放到已排序序列的末尾。
重復第二步，直到所有元素均排序完畢。
將第一待排序序列第一個元素看做一個有序序列，把第二個元素到最后一個元素當成是未排序序列。
從頭到尾依次掃描未排序序列，將掃描到的每個元素插入有序序列的適當位置。（如果待插入的元素與有序序列中的某個元素相等，則將待插入元素插入到相等元素的后面。）

插入排序在對幾乎已經排好序的數據操作時，效率高，即可以達到線性排序的效率；
但插入排序一般來說是低效的，因為插入排序每次只能將數據移動一位；

選擇一個增量序列 t1，t2，……，tk，其中 ti > tj, tk = 1；
按增量序列個數 k，對序列進行 k 趟排序；
每趟排序，根據對應的增量 ti，將待排序列分割成若干長度為 m 的子序列，分別對各子表進行直接插入排序。僅增量因子為 1 時，整個序列作為一個表來處理，表長度即為整個序列的長度。

自上而下的遞歸（所有遞歸的方法都可以用迭代重寫，所以就有了第 2 種方法）；
自下而上的迭代；

申請空間，使其大小為兩個已經排序序列之和，該空間用來存放合并后的序列；
設定兩個指針，最初位置分別為兩個已經排序序列的起始位置；
比較兩個指針所指向的元素，選擇相對小的元素放入到合并空間，并移動指針到下一位置；
重復步驟 3 直到某一指針達到序列尾；
將另一序列剩下的所有元素直接復制到合并序列尾。
從數列中挑出一個元素，稱為 “基準”（pivot）;
重新排序數列，所有元素比基準值小的擺放在基準前面，所有元素比基準值大的擺在基準的后面（相同的數可以到任一邊）。在這個分區退出之后，該基準就處于數列的中間位置。這個稱為分區（partition）操作；
遞歸地（recursive）把小于基準值元素的子數列和大于基準值元素的子數列排序；

3. Python 代碼實現

def quickSort(arr, left=None, right=None):left = 0 if not isinstance(left,(int, float)) else leftright = len(arr)-1 if not isinstance(right,(int, float)) else rightif left < right:partitionIndex = partition(arr, left, right)quickSort(arr, left, partitionIndex-1)quickSort(arr, partitionIndex+1, right)return arrdef partition(arr, left, right):pivot = leftindex = pivot+1i = indexwhile ?i <= right:if arr[i] < arr[pivot]:swap(arr, i, index)index+=1i+=1swap(arr,pivot,index-1)return index-1def swap(arr, i, j):arr[i], arr[j] = arr[j], arr[i]

堆排序

堆排序（Heapsort）是指利用堆這種數據結構所設計的一種排序算法。堆積是一個近似完全二叉樹的結構，并同時滿足堆積的性質：即子結點的鍵值或索引總是小于（或者大于）它的父節點。堆排序可以說是一種利用堆的概念來排序的選擇排序。分為兩種方法：

堆排序的平均時間復雜度為 Ο(nlogn)。

1. 算法步驟

2. 動圖演示

3. Python 代碼實現

def buildMaxHeap(arr):import mathfor i in range(math.floor(len(arr)/2),-1,-1):heapify(arr,i)def heapify(arr, i):left = 2*i+1right = 2*i+2largest = iif left < arrLen and arr[left] > arr[largest]:largest = leftif right < arrLen and arr[right] > arr[largest]:largest = rightif 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 arrLenarrLen = len(arr)buildMaxHeap(arr)for i in range(len(arr)-1,0,-1):swap(arr,0,i)arrLen -=1heapify(arr, 0)return arr

計數排序

計數排序的核心在于將輸入的數據值轉化為鍵存儲在額外開辟的數組空間中。作為一種線性時間復雜度的排序，計數排序要求輸入的數據必須是有確定范圍的整數。

1. 動圖演示

2. Python 代碼實現

def countingSort(arr, maxValue):bucketLen = maxValue+1bucket = [0]*bucketLensortedIndex =0arrLen = len(arr)for i in range(arrLen):if not bucket[arr[i]]:bucket[arr[i]]=0bucket[arr[i]]+=1for j in range(bucketLen):while bucket[j]>0:arr[sortedIndex] = jsortedIndex+=1bucket[j]-=1return arr

桶排序也叫計數排序，

簡單來說，就是將數據集里面所有元素按順序列舉出來，然后統計元素出現的次數。最后按順序輸出數據集里面的元素

總體來說，桶排序的優點就是特別快，真的是特別快！特別快！特別塊！

而缺點就是特別耗資源，如果數據取值的范圍是0---1010, 就要申請一個大小為1010的數組，想想這得多耗內存空間。

闊怕！且桶排序只能排序大于零的整數。

1. 什么時候最快

當輸入的數據可以均勻的分配到每一個桶中。

2. 什么時候最慢

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

3.代碼示例

def bucketSort(nums):# 選擇一個最大的數max_num = max(nums)# 創建一個元素全是0的列表, 當做桶bucket = [0]*(max_num+1)# 把所有元素放入桶中, 即把對應元素個數加一for i in nums:bucket[i] += 1# 存儲排序好的元素sort_nums = []# 取出桶中的元素for j in range(len(bucket)):if bucket[j] != 0:for y in range(bucket[j]):sort_nums.append(j)return sort_numsprint(bucketSort(nums))"""
[0, 0, 1, 2, 2, 3, 5, 6, 8, 65]

基數排序

基數排序是一種非比較型整數排序算法，其原理是將整數按位數切割成不同的數字，然后按每個位數分別比較。由于整數也可以表達字符串（比如名字或日期）和特定格式的浮點數，所以基數排序也不是只能使用于整數。

LSD 基數排序動圖演示

def RadixSort(a):i = 0                                             #初始為個位排序n = 1                                           #最小的位數置為1（包含0）max_num = max(a)                       #得到帶排序數組中最大數while max_num > 10**n:              #得到最大數是幾位數n += 1while i < n:bucket = {}                             #用字典構建桶for x in range(10):bucket.setdefault(x, [])    #將每個桶置空for x in a:                               #對每一位進行排序radix =int((x / (10**i)) % 10)   #得到每位的基數bucket[radix].append(x) #將對應的數組元素加入到相應位基數的桶中j = 0for k in range(10):if len(bucket[k]) != 0:       #若桶不為空for y in bucket[k]:         #將該桶中每個元素a[j] = y                       #放回到數組中j += 1i += 1if __name__ == '__main__':a = [12,3,45,3543,214,1,4553]print("Before sorting...")print("---------------------------------------------------------------")print(a)print("---------------------------------------------------------------")RadixSort(a)print("After sorting...")print("---------------------------------------------------------------")print(a)print("---------------------------------------------------------------")

打印結果：

Before sorting...
---------------------------------------------------------------
[12, 3, 45, 3543, 214, 1, 4553]
---------------------------------------------------------------
After sorting...
---------------------------------------------------------------
[1, 3, 12, 45, 214, 3543, 4553]
---------------------------------------------------------------?

總結/對比/基數排序 vs 計數排序 vs 桶排序：