前言

八大排序，三大查詢是《資料結構》當中非常基礎的知識點，在這裡為了複習順帶總結了一下常見的八種排序演算法。
常見的八大排序演算法，他們之間關係如下：

排序演算法.png

他們的效能比較：

下面，利用Python分別將他們進行實現。

直接插入排序

• 演算法思想：

直接插入排序.gif

直接插入排序的核心思想就是：將陣列中的所有元素依次跟前面已經排好的元素相比較，如果選擇的元素比已排序的元素小，則交換，直到全部元素都比較過。
因此，從上面的描述中我們可以發現，直接插入排序可以用兩個迴圈完成：

1. 第一層迴圈：遍歷待比較的所有陣列元素
2. 第二層迴圈：將本輪選擇的元素(selected)與已經排好序的元素(ordered)相比較。
   如果：selected > ordered，那麼將二者交換

• 程式碼實現

#直接插入排序
def insert_sort(L):
    #遍歷陣列中的所有元素，其中0號索引元素預設已排序，因此從1開始
    for x in range(1,len(L)):
    #將該元素與已排序好的前序陣列依次比較，如果該元素小，則交換
    #range(x-1,-1,-1):從x-1倒序迴圈到0
        for i in range(x-1,-1,-1):
    #判斷：如果符合條件則交換
            if L[i] > L[i+1]:
                temp = L[i+1]
                L[i+1] = L[i]
                L[i] = temp
 

希爾排序

• 演算法思想：

希爾排序.png

希爾排序的演算法思想：將待排序陣列按照步長gap進行分組，然後將每組的元素利用直接插入排序的方法進行排序；每次將gap折半減小，迴圈上述操作；當gap=1時，利用直接插入，完成排序。
同樣的：從上面的描述中我們可以發現：希爾排序的總體實現應該由三個迴圈完成：

1. 第一層迴圈：將gap依次折半，對序列進行分組，直到gap=1
2. 第二、三層迴圈：也即直接插入排序所需要的兩次迴圈。具體描述見上。

• 程式碼實現：

#希爾排序
def insert_shell(L):
    #初始化gap值，此處利用序列長度的一般為其賦值
    gap = (int)(len(L)/2)
    #第一層迴圈：依次改變gap值對列表進行分組
    while (gap >= 1):
    #下面：利用直接插入排序的思想對分組資料進行排序
    #range(gap,len(L)):從gap開始
        for x in range(gap,len(L)):
    #range(x-gap,-1,-gap):從x-gap開始與選定元素開始倒序比較，每個比較元素之間間隔gap
            for i in range(x-gap,-1,-gap):
    #如果該組當中兩個元素滿足交換條件，則進行交換
                if L[i] > L[i+gap]:
                    temp = L[i+gap]
                    L[i+gap] = L[i]
                    L[i] =temp
    #while迴圈條件折半
        gap = (int)(gap/2)
 

簡單選擇排序

• 演算法思想

簡單選擇排序.gif

簡單選擇排序的基本思想：比較+交換。

1. 從待排序序列中，找到關鍵字最小的元素；
2. 如果最小元素不是待排序序列的第一個元素，將其和第一個元素互換；
3. 從餘下的 N - 1 個元素中，找出關鍵字最小的元素，重複(1)、(2)步，直到排序結束。
   因此我們可以發現，簡單選擇排序也是通過兩層迴圈實現。
   第一層迴圈：依次遍歷序列當中的每一個元素
   第二層迴圈：將遍歷得到的當前元素依次與餘下的元素進行比較，符合最小元素的條件，則交換。

• 程式碼實現

# 簡單選擇排序
def select_sort(L):
#依次遍歷序列中的每一個元素
    for x in range(0,len(L)):
#將當前位置的元素定義此輪迴圈當中的最小值
        minimum = L[x]
#將該元素與剩下的元素依次比較尋找最小元素
        for i in range(x+1,len(L)):
            if L[i] < minimum:
                temp = L[i];
                L[i] = minimum;
                minimum = temp
#將比較後得到的真正的最小值賦值給當前位置
        L[x] = minimum

堆排序

• 堆的概念
  堆：本質是一種陣列物件。特別重要的一點性質：<b>任意的葉子節點小於（或大於）它所有的父節點</b>。對此，又分為大頂堆和小頂堆，大頂堆要求節點的元素都要大於其孩子，小頂堆要求節點元素都小於其左右孩子，兩者對左右孩子的大小關係不做任何要求。
  利用堆排序，就是基於大頂堆或者小頂堆的一種排序方法。下面，我們通過大頂堆來實現。

• 基本思想：
  堆排序可以按照以下步驟來完成：

  1. 首先將序列構建稱為大頂堆；
     （這樣滿足了大頂堆那條性質：位於根節點的元素一定是當前序列的最大值）

      

     

     構建大頂堆.png

  2. 取出當前大頂堆的根節點，將其與序列末尾元素進行交換；
     （此時：序列末尾的元素為已排序的最大值；由於交換了元素，當前位於根節點的堆並不一定滿足大頂堆的性質）

  3. 對交換後的n-1個序列元素進行調整，使其滿足大頂堆的性質；

      

     

     Paste_Image.png

  4. 重複2.3步驟，直至堆中只有1個元素為止

• 程式碼實現：

#-------------------------堆排序--------------------------------
#**********獲取左右葉子節點**********
def LEFT(i):
    return 2*i + 1
def RIGHT(i):
    return 2*i + 2
#********** 調整大頂堆 **********
#L:待調整序列 length: 序列長度 i:需要調整的結點
def adjust_max_heap(L,length,i):
#定義一個int值儲存當前序列最大值的下標
    largest = i
#執行迴圈操作：兩個任務：1 尋找最大值的下標；2.最大值與父節點交換
    while (1):
#獲得序列左右葉子節點的下標
        left,right = LEFT(i),RIGHT(i)
#當左葉子節點的下標小於序列長度 並且 左葉子節點的值大於父節點時，將左葉子節點的下標賦值給largest
        if (left < length) and (L[left] > L[i]):
            largest = left
            print('左葉子節點')
        else:
            largest = i
#當右葉子節點的下標小於序列長度 並且 右葉子節點的值大於父節點時，將右葉子節點的下標值賦值給largest
        if (right < length) and (L[right] > L[largest]):
            largest = right
            print('右葉子節點')
#如果largest不等於i 說明當前的父節點不是最大值，需要交換值
        if (largest != i):
            temp = L[i]
            L[i] = L[largest]
            L[largest] = temp
            i = largest
            print(largest)
            continue
        else:
            break
#********** 建立大頂堆 **********
def build_max_heap(L):
    length = len(L)
    for x in range((int)((length-1)/2),-1,-1):
        adjust_max_heap(L,length,x)
#********** 堆排序 **********
def heap_sort(L):
#先建立大頂堆，保證最大值位於根節點；並且父節點的值大於葉子結點
    build_max_heap(L)
#i：當前堆中序列的長度.初始化為序列的長度
    i = len(L)
#執行迴圈：1. 每次取出堆頂元素置於序列的最後(len-1,len-2,len-3...)
#         2. 調整堆，使其繼續滿足大頂堆的性質，注意實時修改堆中序列的長度
    while (i > 0):
        temp = L[i-1]
        L[i-1] = L[0]
        L[0] = temp
#堆中序列長度減1
        i = i-1
#調整大頂堆
        adjust_max_heap(L,i,0)

氣泡排序

• 基本思想

   

  

  氣泡排序.gif

   

  氣泡排序思路比較簡單：

  1. 將序列當中的左右元素，依次比較，保證右邊的元素始終大於左邊的元素；
     （ 第一輪結束後，序列最後一個元素一定是當前序列的最大值；）
  2. 對序列當中剩下的n-1個元素再次執行步驟1。
  3. 對於長度為n的序列，一共需要執行n-1輪比較
     （利用while迴圈可以減少執行次數）

*程式碼實現

#氣泡排序
def bubble_sort(L):
    length = len(L)
#序列長度為length，需要執行length-1輪交換
    for x in range(1,length):
#對於每一輪交換，都將序列當中的左右元素進行比較
#每輪交換當中，由於序列最後的元素一定是最大的，因此每輪迴圈到序列未排序的位置即可
        for i in range(0,length-x):
            if L[i] > L[i+1]:
                temp = L[i]
                L[i] = L[i+1]
                L[i+1] = temp

快速排序

• 演算法思想：

  

  快速排序.gif

  
  快速排序的基本思想：挖坑填數+分治法
  1. 從序列當中選擇一個基準數(pivot)
     在這裡我們選擇序列當中第一個數最為基準數
  2. 將序列當中的所有數依次遍歷，比基準數大的位於其右側，比基準數小的位於其左側
  3. 重複步驟1.2，直到所有子集當中只有一個元素為止。
     用虛擬碼描述如下：
     1．i =L; j = R; 將基準數挖出形成第一個坑a[i]。
     2．j--由後向前找比它小的數，找到後挖出此數填前一個坑a[i]中。
     3．i++由前向後找比它大的數，找到後也挖出此數填到前一個坑a[j]中。
     4．再重複執行2，3二步，直到i==j，將基準數填入a[i]中
• 程式碼實現：

#快速排序
#L：待排序的序列；start排序的開始index,end序列末尾的index
#對於長度為length的序列：start = 0;end = length-1
def quick_sort(L,start,end):
    if start < end:
        i , j , pivot = start , end , L[start]
        while i < j:
#從右開始向左尋找第一個小於pivot的值
            while (i < j) and (L[j] >= pivot):
                j = j-1
#將小於pivot的值移到左邊
            if (i < j):
                L[i] = L[j]
                i = i+1 
#從左開始向右尋找第一個大於pivot的值
            while (i < j) and (L[i] < pivot):
                i = i+1
#將大於pivot的值移到右邊
            if (i < j):
                L[j] = L[i]
                j = j-1
#迴圈結束後，說明 i=j，此時左邊的值全都小於pivot,右邊的值全都大於pivot
#pivot的位置移動正確，那麼此時只需對左右兩側的序列呼叫此函式進一步排序即可
#遞迴呼叫函式：依次對左側序列：從0 ~ i-1//右側序列：從i+1 ~ end
        L[i] = pivot
#左側序列繼續排序
        quick_sort(L,start,i-1)
#右側序列繼續排序
        quick_sort(L,i+1,end)

歸併排序

• 演算法思想：

   

  

  歸併排序.gif

  1. 歸併排序是建立在歸併操作上的一種有效的排序演算法，該演算法是採用分治法的一個典型的應用。它的基本操作是：將已有的子序列合併，達到完全有序的序列；即先使每個子序列有序，再使子序列段間有序。
  2. 歸併排序其實要做兩件事：
  • 分解----將序列每次折半拆分
  • 合併----將劃分後的序列段兩兩排序合併
    因此，歸併排序實際上就是兩個操作，拆分+合併
  1. 如何合併？
     L[first...mid]為第一段，L[mid+1...last]為第二段，並且兩端已經有序，現在我們要將兩端合成達到L[first...last]並且也有序。
  • 首先依次從第一段與第二段中取出元素比較，將較小的元素賦值給temp[]
  • 重複執行上一步，當某一段賦值結束，則將另一段剩下的元素賦值給temp[]
  • 此時將temp[]中的元素複製給L[]，則得到的L[first...last]有序
  1. 如何分解？
     在這裡，我們採用遞迴的方法，首先將待排序列分成A,B兩組；然後重複對A、B序列
     分組；直到分組後組內只有一個元素，此時我們認為組內所有元素有序，則分組結束。

• 程式碼實現

# 歸併排序
#這是合併的函式
# 將序列L[first...mid]與序列L[mid+1...last]進行合併
def mergearray(L,first,mid,last,temp):
#對i,j,k分別進行賦值
    i,j,k = first,mid+1,0
#當左右兩邊都有數時進行比較，取較小的數
    while (i <= mid) and (j <= last):
        if L[i] <= L[j]:
            temp[k] = L[i]
            i = i+1
            k = k+1
        else:
            temp[k] = L[j]
            j = j+1
            k = k+1
#如果左邊序列還有數
    while (i <= mid):
        temp[k] = L[i]
        i = i+1
        k = k+1
#如果右邊序列還有數
    while (j <= last):
        temp[k] = L[j]
        j = j+1
        k = k+1
#將temp當中該段有序元素賦值給L待排序列使之部分有序
    for x in range(0,k):
        L[first+x] = temp[x]
# 這是分組的函式
def merge_sort(L,first,last,temp):
    if first < last:
        mid = (int)((first + last) / 2)
#使左邊序列有序
        merge_sort(L,first,mid,temp)
#使右邊序列有序
        merge_sort(L,mid+1,last,temp)
#將兩個有序序列合併
        mergearray(L,first,mid,last,temp)
# 歸併排序的函式
def merge_sort_array(L):
#宣告一個長度為len(L)的空列表
    temp = len(L)*[None]
#呼叫歸併排序
    merge_sort(L,0,len(L)-1,temp)

基數排序

• 演算法思想

   

  

  基數排序.gif

  1. 基數排序：通過序列中各個元素的值，對排序的N個元素進行若干趟的“分配”與“收集”來實現排序。
     分配：我們將L[i]中的元素取出，首先確定其個位上的數字，根據該數字分配到與之序號相同的桶中
     收集：當序列中所有的元素都分配到對應的桶中，再按照順序依次將桶中的元素收集形成新的一個待排序列L[ ]
     對新形成的序列L[]重複執行分配和收集元素中的十位、百位...直到分配完該序列中的最高位，則排序結束
  2. 根據上述“基數排序”的展示，我們可以清楚的看到整個實現的過程
• 程式碼實現

#************************基數排序****************************
#確定排序的次數
#排序的順序跟序列中最大數的位數相關
def radix_sort_nums(L):
    maxNum = L[0]
#尋找序列中的最大數
    for x in L:
        if maxNum < x:
            maxNum = x
#確定序列中的最大元素的位數
    times = 0
    while (maxNum > 0):
        maxNum = (int)(maxNum/10)
        times = times+1
    return times
#找到num從低到高第pos位的資料
def get_num_pos(num,pos):
    return ((int)(num/(10**(pos-1))))%10
#基數排序
def radix_sort(L):
    count = 10*[None]       #存放各個桶的資料統計個數
    bucket = len(L)*[None]  #暫時存放排序結果
#從低位到高位依次執行迴圈
    for pos in range(1,radix_sort_nums(L)+1):
        #置空各個桶的資料統計
        for x in range(0,10):
            count[x] = 0
        #統計當前該位(個位，十位，百位....)的元素數目
        for x in range(0,len(L)):
            #統計各個桶將要裝進去的元素個數
            j = get_num_pos(int(L[x]),pos)
            count[j] = count[j]+1
        #count[i]表示第i個桶的右邊界索引
        for x in range(1,10):
            count[x] = count[x] + count[x-1]
        #將資料依次裝入桶中
        for x in range(len(L)-1,-1,-1):
            #求出元素第K位的數字
            j = get_num_pos(L[x],pos)
            #放入對應的桶中，count[j]-1是第j個桶的右邊界索引
            bucket[count[j]-1] = L[x]
            #對應桶的裝入資料索引-1
            count[j] = count[j]-1
        # 將已分配好的桶中資料再倒出來，此時已是對應當前位數有序的表
        for x in range(0,len(L)):
            L[x] = bucket[x]

後記

寫完之後運行了一下時間比較：

• 1w個數據時：

直接插入排序:11.615608
希爾排序:13.012008
簡單選擇排序:3.645136000000001
堆排序:0.09587900000000005
氣泡排序:6.687218999999999
#****************************************************
快速排序:9.999999974752427e-07 
#快速排序有誤：實際上並未執行
#RecursionError: maximum recursion depth exceeded in comparison
#****************************************************
歸併排序:0.05638299999999674
基數排序:0.08150400000000246

• 10w個數據時：

直接插入排序:1233.581131
希爾排序:1409.8012320000003
簡單選擇排序:466.66974500000015
堆排序:1.2036720000000969
氣泡排序:751.274449
#****************************************************
快速排序:1.0000003385357559e-06
#快速排序有誤：實際上並未執行
#RecursionError: maximum recursion depth exceeded in comparison
#****************************************************
歸併排序:0.8262230000000272
基數排序:1.1162899999999354

從執行結果上來看，堆排序、歸併排序、基數排序真的快。
對於快速排序迭代深度超過的問題，可以將考慮將快排通過非遞迴的方式進行實現。

參考資料