十大排序算法（Python實現）

一. 算法介紹及相關概念解讀

算法分類

十種常見排序算法可以分爲兩大類：

非線性時間比較類排序：通過比較來決定元素間的相對次序，由於其時間複雜度不能突破O(nlogn)，因此稱爲非線性時間比較類排序。

線性時間非比較類排序：不通過比較來決定元素間的相對次序，它可以突破基於比較排序的時間下界，以線性時間運行，因此稱爲線性時間非比較類排序。

1. 交換排序

1.1 冒泡排序(Bubble Sort)

比較相鄰的元素。如果第一個比第二個大，就交換它們兩個；

對每一對相鄰元素作同樣的工作，從開始第一對到結尾的最後一對，這樣在最後的元素應該會是最大的數；

針對所有的元素重複以上的步驟，除了最後一個；

重複步驟1~3，直到排序完成。

冒泡排序對n個數據操作n-1輪，每輪找出一個最大（小）值。

操作只對相鄰兩個數比較與交換，每輪會將一個最值交換到數據列首（尾），像冒泡一樣。

每輪操作O(n)次，共O（n）輪，時間複雜度O(n^2)。

額外空間開銷出在交換數據時那一個過渡空間，空間複雜度O(1)

def BubbleSort(lst):
    n=len(lst)
    if n<=1:
        return lst
    for i in range (0,n):
        for j in range(0,n-i-1):
            if lst[j]>lst[j+1]:
                (lst[j],lst[j+1])=(lst[j+1],lst[j])
    return lst
x=input("請輸入待排序數列：\n")
y=x.split()
arr=[]
for i in  y:
    arr.append(int(i))
arr=BubbleSort(arr)
#print(arr)
print("數列按序排列如下：")
for i in arr:
    print(i,end=' ')

1.2 快速排序(Quick Sort)

從數列中挑出一個元素，稱爲 “基準”（pivot）；

重新排序數列，所有元素比基準值小的擺放在基準前面，所有元素比基準值大的擺在基準的後面（相同的數可以到任一邊）。在這個分區退出之後，該基準就處於數列的中間位置。這個稱爲分區（partition）操作；

遞歸地（recursive）把小於基準值元素的子數列和大於基準值元素的子數列排序。

快速排序基於選擇劃分，是簡單選擇排序的優化。

每次劃分將數據選到基準值兩邊，循環對兩邊的數據進行劃分，類似於二分法。

算法的整體性能取決於劃分的平均程度，即基準值的選擇，此處衍生出快速排序的許多優化方案，甚至可以劃分爲多塊。

基準值若能把數據分爲平均的兩塊，劃分次數O(logn)，每次劃分遍歷比較一遍O(n)，時間複雜度O(nlogn)。

額外空間開銷出在暫存基準值，O(logn)次劃分需要O(logn)個，空間複雜度O(logn)

def QuickSort(lst):
    # 此函數完成分區操作
    def partition(arr, left, right):
        key = left  # 劃分參考數索引,默認爲第一個數爲基準數，可優化
        while left < right:
            # 如果列表後邊的數,比基準數大或相等,則前移一位直到有比基準數小的數出現
            while left < right and arr[right] >= arr[key]:
                right -= 1
            # 如果列表前邊的數,比基準數小或相等,則後移一位直到有比基準數大的數出現
            while left < right and arr[left] <= arr[key]:
                left += 1
            # 此時已找到一個比基準大的書，和一個比基準小的數，將他們互換位置
            (arr[left], arr[right]) = (arr[right], arr[left])

        # 當從兩邊分別逼近，直到兩個位置相等時結束，將左邊小的同基準進行交換
        (arr[left], arr[key]) = (arr[key], arr[left])
        # 返回目前基準所在位置的索引
        return left

    def quicksort(arr, left, right):  
        if left >= right:
            return
        # 從基準開始分區
        mid = partition(arr, left, right)
        # 遞歸調用
        # print(arr)
        quicksort(arr, left, mid - 1)
        quicksort(arr, mid + 1, right)

    # 主函數
    n = len(lst)
    if n <= 1:
        return lst
    quicksort(lst, 0, n - 1)
    return lst

print("<<< Quick Sort >>>")
x = input("請輸入待排序數列：\n")
y = x.split()
arr = []
for i in y:
    arr.append(int(i))
arr = QuickSort(arr)
# print(arr)
print("數列按序排列如下：")
for i in arr:
    print(i, end=' ')

2. 插入排序

2.1 簡單插入排序(Insert Sort)

從第一個元素開始，該元素可以認爲已經被排序；

取出下一個元素，在已經排序的元素序列中從後向前掃描；

如果該元素（已排序）大於新元素，將該元素移到下一位置；

重複步驟3，直到找到已排序的元素小於或者等於新元素的位置；

將新元素插入到該位置後；

重複步驟2~5。

簡單插入排序同樣操作n-1輪，每輪將一個未排序樹插入排好序列。

開始時默認第一個數有序，將剩餘n-1個數逐個插入。插入操作具體包括：比較確定插入位置，數據移位騰出合適空位

每輪操作O(n)次，共O（n）輪，時間複雜度O(n^2)。

額外空間開銷出在數據移位時那一個過渡空間，空間複雜度O(1)。

def InsertSort(lst):
    n=len(lst)
    if n<=1:
        return lst
    for i in range(1,n):
        j=i
        target=lst[i]            #每次循環的一個待插入的數
        while j>0 and target<lst[j-1]:       #比較、後移，給target騰位置
            lst[j]=lst[j-1]
            j=j-1
        lst[j]=target            #把target插到空位
    return lst
 
x=input("請輸入待排序數列：\n")
y=x.split()
arr=[]
for i in  y:
    arr.append(int(i))
arr=InsertSort(arr)
#print(arr)
print("數列按序排列如下：")
for i in arr:
    print(i,end=' ')

2.2 希爾排序(Shell Sort)

先將整個待排序的記錄序列分割成爲若干子序列分別進行直接插入排序，具體算法描述：

選擇一個增量序列t1，t2，…，tk，其中ti>tj，tk=1；

按增量序列個數k，對序列進行k 趟排序；

每趟排序，根據對應的增量ti，將待排序列分割成若干長度爲m 的子序列，分別對各子表進行直接插入排序。僅增量因子爲1 時，整個序列作爲一個表來處理，表長度即爲整個序列的長度。

希爾排序是插入排序的高效實現（大家可以比對一下插入排序和希爾排序的代碼），對簡單插入排序減少移動次數優化而來。

簡單插入排序每次插入都要移動大量數據，前後插入時的許多移動都是重複操作，若一步到位移動效率會高很多。

若序列基本有序，簡單插入排序不必做很多移動操作，效率很高。

希爾排序將序列按固定間隔劃分爲多個子序列，在子序列中簡單插入排序，先做遠距離移動使序列基本有序；逐漸縮小間隔重複操作，最後間隔爲1時即簡單插入排序。

希爾排序對序列劃分O(n)次，每次簡單插入排序O(logn)，時間複雜度O(nlogn)

額外空間開銷出在插入過程數據移動需要的一個暫存，空間複雜度O(1)

def ShellSort(lst):
    def shellinsert(arr,d):
        n=len(arr)
        for i in range(d,n):
            j=i-d
            temp=arr[i]             #記錄要出入的數
            while(j>=0 and arr[j]>temp):    #從後向前，找打比其小的數的位置
                arr[j+d]=arr[j]                 #向後挪動
                j-=d
            if j!=i-d:
                arr[j+d]=temp
    n=len(lst)
    if n<=1:
        return lst
    d=n//2
    while d>=1:
        shellinsert(lst,d)
        d=d//2
    return lst
 
 
x=input("請輸入待排序數列：\n")
y=x.split()
arr=[]
for i in  y:
    arr.append(int(i))
arr=ShellSort(arr)
#print(arr)
print("數列按序排列如下：")
for i in arr:
    print(i,end=' ')

希爾排序的核心在於間隔序列的設定。既可以提前設定好間隔序列，也可以動態的定義間隔序列。動態定義間隔序列的算法是《算法（第4版）》的合著者Robert Sedgewick提出的。　

3.選擇排序

3.1 簡單選擇排序(Select Sort)

初始狀態：無序區爲R[1..n]，有序區爲空；

第i趟排序(i=1,2,3…n-1)開始時，當前有序區和無序區分別爲R[1..i-1]和R(i..n）。該趟排序從當前無序區中-選出關鍵字最小的記錄 R[k]，將它與無序區的第1個記錄R交換，使R[1..i]和R[i+1..n)分別變爲記錄個數增加1個的新有序區和記錄個數減少1個的新無序區；

n-1趟結束，數組有序化了。

簡單選擇排序同樣對數據操作n-1輪，每輪找出一個最大（小）值。

操作指選擇，即未排序數逐個比較交換，爭奪最值位置，每輪將一個未排序位置上的數交換成已排序數，即每輪選一個最值。

每輪操作O(n)次，共O（n）輪，時間複雜度O(n^2)。

額外空間開銷出在交換數據時那一個過渡空間，空間複雜度O(1)。

def SelectSort(lst):
    n=len(lst)
    if n<=1:
        return lst
    for i in range(0,n-1):
        minIndex=i
        for j in range(i+1,n):          #比較一遍，記錄索引不交換
            if lst[j]<lst[minIndex]:
                minIndex=j
        if minIndex!=i:                     #按索引交換
            (lst[minIndex],lst[i])=(lst[i],lst[minIndex])
    return lst
 
x=input("請輸入待排序數列：\n")
y=x.split()
arr=[]
for i in  y:
    arr.append(int(i))
arr=SelectSort(arr)
#print(arr)
print("數列按序排列如下：")
for i in arr:
    print(i,end=' ')

表現最穩定的排序算法之一，因爲無論什麼數據進去都是O(n2)的時間複雜度，所以用到它的時候，數據規模越小越好。唯一的好處可能就是不佔用額外的內存空間了吧。理論上講，選擇排序可能也是平時排序一般人想到的最多的排序方法了吧。

3.2 堆排序(Heap Sort)

堆排序（Heapsort）是指利用堆這種數據結構所設計的一種排序算法。堆積是一個近似完全二叉樹的結構，並同時滿足堆積的性質：即子結點的鍵值或索引總是小於（或者大於）它的父節點。

將初始待排序關鍵字序列(R1,R2….Rn)構建成大頂堆，此堆爲初始的無序區；

將堆頂元素R[1]與最後一個元素R[n]交換，此時得到新的無序區(R1,R2,……Rn-1)和新的有序區(Rn),且滿足R[1,2…n-1]<=R[n]；

由於交換後新的堆頂R[1]可能違反堆的性質，因此需要對當前無序區(R1,R2,……Rn-1)調整爲新堆，然後再次將R[1]與無序區最後一個元素交換，得到新的無序區(R1,R2….Rn-2)和新的有序區(Rn-1,Rn)。不斷重複此過程直到有序區的元素個數爲n-1，則整個排序過程完成。

堆排序的初始建堆過程比價複雜，對O(n)級別個非葉子節點進行堆調整操作O(logn)，時間複雜度O(nlogn)；之後每一次堆調整操作確定一個數的次序，時間複雜度O(nlogn)。合起來時間複雜度O(nlogn)

額外空間開銷出在調整堆過程，根節點下移交換時一個暫存空間，空間複雜度O(1)

def  HeapSort(lst):
    def heapadjust(arr,start,end):  #將以start爲根節點的堆調整爲大頂堆
        temp=arr[start]
        son=2*start+1
        while son<=end:
            if son<end and arr[son]<arr[son+1]:  #找出左右孩子節點較大的
                son+=1
            if temp>=arr[son]:       #判斷是否爲大頂堆
                break
            arr[start]=arr[son]     #子節點上移
            start=son                     #繼續向下比較
            son=2*son+1
        arr[start]=temp             #將原堆頂插入正確位置
#######
    n=len(lst)
    if n<=1:
        return lst
    #建立大頂堆
    root=n//2-1    #最後一個非葉節點（完全二叉樹中）
    while(root>=0):
        heapadjust(ls,root,n-1)
        root-=1
    #掐掉堆頂後調整堆
    i=n-1
    while(i>=0):
        (lst[0],lst[i])=(lst[i],lst[0])  #將大頂堆堆頂數放到最後
        heapadjust(lst,0,i-1)    #調整剩餘數組成的堆
        i-=1
    return lst
#########
x=input("請輸入待排序數列：\n")
y=x.split()
arr=[]
for i in  y:
    arr.append(int(i))
arr=HeapSort(arr)
#print(arr)
print("數列按序排列如下：")
for i in arr:
    print(i,end=' ')

4. 歸併排序

4.1 二路歸併排序(Two-way Merge Sort)

歸併排序是建立在歸併操作上的一種有效的排序算法。該算法是採用分治法（Divide and Conquer）的一個非常典型的應用。將已有序的子序列合併，得到完全有序的序列；即先使每個子序列有序，再使子序列段間有序。若將兩個有序表合併成一個有序表，稱爲2-路歸併。

把長度爲n的輸入序列分成兩個長度爲n/2的子序列；

對這兩個子序列分別採用歸併排序；

將兩個排序好的子序列合併成一個最終的排序序列。

def MergeSort(lst):
    #合併左右子序列函數
    def merge(arr,left,mid,right):
        temp=[]     #中間數組
        i=left          #左段子序列起始
        j=mid+1   #右段子序列起始
        while i<=mid and j<=right:
            if arr[i]<=arr[j]:
                temp.append(arr[i])
                i+=1
            else:
                temp.append(arr[j])
                j+=1
        while i<=mid:
            temp.append(arr[i])
            i+=1
        while j<=right:
            temp.append(arr[j])
            j+=1
        for i in range(left,right+1):    #  !注意這裏，不能直接arr=temp,他倆大小都不一定一樣
            arr[i]=temp[i-left]
    #遞歸調用歸併排序
    def mSort(arr,left,right):
        if left>=right:
            return
        mid=(left+right)//2
        mSort(arr,left,mid)
        mSort(arr,mid+1,right)
        merge(arr,left,mid,right)
 
    n=len(lst)
    if n<=1:
        return lst
    mSort(lst,0,n-1)
    return lst
 
x=input("請輸入待排序數列：\n")
y=x.split()
arr=[]
for i in  y:
    arr.append(int(i))
arr=MergeSort(arr)
#print(arr)
print("數列按序排列如下：")
for i in arr:
    print(i,end=' ')

歸併排序是一種穩定的排序方法。和選擇排序一樣，歸併排序的性能不受輸入數據的影響，但表現比選擇排序好的多，因爲始終都是O(nlogn）的時間複雜度。代價是需要額外的內存空間。

5. 線性時間非比較類排序

5.1 計數排序（Counting Sort）

找出待排序的數組中最大和最小的元素；

統計數組中每個值爲i的元素出現的次數，存入數組C的第i項；

對所有的計數累加（從C中的第一個元素開始，每一項和前一項相加）；

反向填充目標數組：將每個元素i放在新數組的第C(i)項，每放一個元素就將C(i)減去1。

計數排序用待排序的數值作爲計數數組（列表）的下標，統計每個數值的個數，然後依次輸出即可。

計數數組的大小取決於待排數據取值範圍，所以對數據有一定要求，否則空間開銷無法承受。

計數排序只需遍歷一次數據，在計數數組中記錄，輸出計數數組中有記錄的下標，時間複雜度爲O(n+k)。

額外空間開銷即指計數數組，實際上按數據值分爲k類（大小取決於數據取值），空間複雜度O(k)。

def CountSort(lst):
    n=len(lst)
    num=max(lst)
    count=[0]*(num+1)
    for i in range(0,n):
        count[lst[i]]+=1
    arr=[]
    for i in range(0,num+1):
        for j in range(0,count[i]):
            arr.append(i)
    return arr
 
 
x=input("請輸入待排序數列：\n")
y=x.split()
arr=[]
for i in  y:
    arr.append(int(i))
arr=CountSort(arr)
#print(arr)
print("數列按序排列如下：")
for i in arr:
    print(i,end=' ')

計數排序是一個穩定的排序算法。當輸入的元素是 n 個 0到 k 之間的整數時，時間複雜度是O(n+k)，空間複雜度也是O(n+k)，其排序速度快於任何比較排序算法。當k不是很大並且序列比較集中時，計數排序是一個很有效的排序算法。

5.2 桶排序（Bucket Sort）

設置一個定量的數組當作空桶；

遍歷輸入數據，並且把數據一個一個放到對應的桶裏去；

對每個不是空的桶進行排序；

從不是空的桶裏把排好序的數據拼接起來。

桶排序實際上是計數排序的推廣，但實現上要複雜許多。

桶排序先用一定的函數關係將數據劃分到不同有序的區域（桶）內，然後子數據分別在桶內排序，之後順次輸出。

當每一個不同數據分配一個桶時，也就相當於計數排序。

假設n個數據，劃分爲k個桶，桶內採用快速排序，時間複雜度爲O(n)+O(k * n/k*log(n/k))=O(n)+O(n*(log(n)-log(k))),

顯然，k越大，時間複雜度越接近O(n)，當然空間複雜度O(n+k)會越大，這是空間與時間的平衡。

def BucketSort(lst):
    ##############桶內使用快速排序
    def QuickSort(lst):
        def partition(arr,left,right):
            key=left         #劃分參考數索引,默認爲第一個數，可優化
            while left<right:
                while left<right and arr[right]>=arr[key]:
                    right-=1
                while left<right and arr[left]<=arr[key]:
                    left+=1
                (arr[left],arr[right])=(arr[right],arr[left])
            (arr[left],arr[key])=(arr[key],arr[left])
            return left
 
        def quicksort(arr,left,right):   #遞歸調用
            if left>=right:
                return
            mid=partition(arr,left,right)
            quicksort(arr,left,mid-1)
            quicksort(arr,mid+1,right)
        #主函數
        n=len(lst)
        if n<=1:
            return lst
        quicksort(lst,0,n-1)
        return lst
    ######################
    n=len(lst)
    big=max(lst)
    num=big//10+1
    bucket=[]
    buckets=[[] for i in range(0,num)]
    for i in lst:
        buckets[i//10].append(i)     #劃分桶
    for i in buckets:                       #桶內排序
        bucket=QuickSort(i)
    arr=[]
    for i in buckets:
        if isinstance(i, list):
            for j in i:
                arr.append(j)
        else:
            arr.append(i)
    for i in range(0,n):
        lst[i]=arr[i]
    return lst
    
x=input("請輸入待排序數列：\n")
y=x.split()
arr=[]
for i in  y:
    arr.append(int(i))
arr=BucketSort(arr)
#print(arr)
print("數列按序排列如下：")
for i in arr:
    print(i,end=' ')

桶排序最好情況下使用線性時間O(n)，桶排序的時間複雜度，取決與對各個桶之間數據進行排序的時間複雜度，因爲其它部分的時間複雜度都爲O(n)。很顯然，桶劃分的越小，各個桶之間的數據越少，排序所用的時間也會越少。但相應的空間消耗就會增大。

5.3 基數排序（Radix Sort）

取得數組中的最大數，並取得位數；

arr爲原始數組，從最低位開始取每個位組成radix數組；

對radix進行計數排序（利用計數排序適用於小範圍數的特點）；

import math
def RadixSort(lst):
    def getbit(x,i):       #返回x的第i位（從右向左，個位爲0）數值
        y=x//pow(10,i)
        z=y%10
        return z
    def CountSort(lst):
        n=len(lst)
        num=max(lst)
        count=[0]*(num+1)
        for i in range(0,n):
            count[lst[i]]+=1
        arr=[]
        for i in range(0,num+1):
            for j in range(0,count[i]):
                arr.append(i)
        return arr
    Max=max(lst)
    for k in range(0,int(math.log10(Max))+1):             #對k位數排k次,每次按某一位來排
        arr=[[] for i in range(0,10)]
        for i in lst:                 #將ls（待排數列）中每個數按某一位分類（0-9共10類）存到arr[][]二維數組（列表）中
            arr[getbit(i,k)].append(i)
        for i in range(0,10):         #對arr[]中每一類（一個列表）  按計數排序排好
            if len(arr[i])>0:
                arr[i]=CountSort(arr[i])
        j=9
        n=len(lst)
        for i in range(0,n):     #順序輸出arr[][]中數到ls中，即按第k位排好
            while len(arr[j])==0:
                j-=1
            else:
                ls[n-1-i]=arr[j].pop()   
    return lst    
    
x=input("請輸入待排序數列：\n")
y=x.split()
arr=[]
for i in  y:
    arr.append(int(i))
arr=RadixSort(arr)
#print(arr)
print("數列按序排列如下：")
for i in arr:
    print(i,end=' ')

基數排序基於分別排序，分別收集，所以是穩定的。但基數排序的性能比桶排序要略差，每一次關鍵字的桶分配都需要O(n)的時間複雜度，而且分配之後得到新的關鍵字序列又需要O(n)的時間複雜度。假如待排數據可以分爲d個關鍵字，則基數排序的時間複雜度將是O(d*2n) ，當然d要遠遠小於n，因此基本上還是線性級別的。

基數排序的空間複雜度爲O(n+k)，其中k爲桶的數量。一般來說n>>k，因此額外空間需要大概n個左右。

參考文獻：

十大經典排序算法（動圖演示）

史上最簡單十大排序算法（Python實現）

十大排序算法（Python實現）

一. 算法介紹及相關概念解讀

算法分類

相關概念

1. 交換排序

1.1 冒泡排序(Bubble Sort)

1.2 快速排序(Quick Sort)

2. 插入排序

2.1 簡單插入排序(Insert Sort)

2.2 希爾排序(Shell Sort)

3.選擇排序

3.1 簡單選擇排序(Select Sort)

3.2 堆排序(Heap Sort)

4. 歸併排序

4.1 二路歸併排序(Two-way Merge Sort)

5. 線性時間非比較類排序

5.1 計數排序（Counting Sort）

5.2 桶排序（Bucket Sort）

5.3 基數排序（Radix Sort）

.NET有哪些好用的定時任務調度框架

Python 將PDF轉爲PDF/A、PDF/X，以及PDF/A轉回PDF

elk3

Kafka存儲機制

aws語音呼叫調用，告警電話

深度學習框架火焰圖pprof和CUDA Nsys配置指南

爬蟲兩種繞過5s盾的方法

【轉】[C#] WebAPI 防止併發調用二（冥等性）

【轉】[SQL Server]關掉 SSMS 的 IntelliSense

號稱能打敗MLP的KAN到底行不行？數學核心原理全面解析

【Pandas數據分析】Pandas 統計特徵函數和統計作圖函數（最簡單的數據探索入門）

Python的22個超實用編程技巧，簡化 if 語句、開啓文件分享……

【機器學習】特徵工程多特徵值序列化數值化獨熱編碼處理(LabelEncoder, pd.factorize())

Jupyter Lab 簡單配置

史上最簡單十大排序算法（Python實現）

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結