2. 程式人生 > 其它 >資料結構常見的八大排序演算法

資料結構常見的八大排序演算法

阿新 • • 發佈：2021-09-13

https://www.jianshu.com/p/7d037c332a9d?utm_campaign=hugo&utm_medium=reader_share&utm_content=note&utm_source=weixin-friends

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

排序演算法.png

他們的效能比較：

效能比較.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

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

相關推薦

【資料結構】——交換排序演算法：氣泡排序、快速排序

技術標籤：資料結構排序演算法資料結構python 一、氣泡排序：（穩定） 1.基本思想

資料結構常見的八大排序演算法

https://www.jianshu.com/p/7d037c332a9d?utm_campaign=hugo&utm_medium=reader_share&utm_content=note&utm_source=weixin-friends

演算法資料結構 | 圖論基礎演算法——拓撲排序

今天是演算法和資料結構專題的第32篇文章，我們來聊聊拓撲排序的問題。 拓撲排序是圖論當中一個非常簡單也非常常用的演算法，它有很多的功能。它可以用來檢測有向圖當中是否存在環，也可以用來解決存在依賴的排程問題

【資料結構】堆排序的向下調整演算法

技術標籤：資料結構資料結構堆排序演算法 演算法解析 要明白向下調整演算法首先要掌握資料結構中堆的定義（不是記憶體中的堆）。 1·概念：堆資料結構是一種陣列物件，它可以被視為一棵完全二叉樹結構。 2

演算法和資料結構—— 查詢和排序

本文為簡書作者鄭永欣原創，CDA資料分析師已獲得授權 查詢和排序都是程式設計中經常用到的演算法。查詢相對而言較為簡單，不外乎順序查詢、二分查詢、雜湊表查詢和二叉排序樹查詢。排序常見的有插入排序、氣泡排序、

面試題: java中常見的排序演算法的實現及比較

目錄1.氣泡排序1.1 氣泡排序普通版1.2 冒泡排序升級版2.選擇排序3.插入排序4.快速排序5.歸併排序6.希爾排序7.基數排序8.堆排序各種演算法的比較

常見的排序演算法

1.二分查詢演算法 public int search(int[] args, int num) { int start = 0; int end = args.length - 1;

八大排序演算法

0、對數器 在瞭解排序演算法之前，引入對數器這一概念，它用於輔助驗證自己寫的排序演算法正確與否。

八大排序演算法詳解（動圖演示 思路分析 例項程式碼java 複雜度分析 適用場景）

內部排序和外部排序　 內部排序：待排序記錄存放在計算機隨機儲存器中（說簡單點，就是記憶體）進行的排序過程。

python 常見的排序演算法實現彙總

排序分為兩類，比較類排序和非比較類排序，比較類排序通過比較來決定元素間的相對次序，其時間複雜度不能突破O(nlogn)；非比較類排序可以突破基於比較排序的時間下界，缺點就是一般只能用於整型相關的資料型別，需要

資料結構—二叉排序樹（Java）

資料結構—二叉排序樹（Java） 部落格說明 文章所涉及的資料來自網際網路整理和個人總結，意在於個人學習和經驗彙總，如有什麼地方侵權，請聯絡本人刪除，謝謝！

資料結構：八大資料結構分類

>>> 資料結構是指相互之間存在著一種或多種關係的資料元素的集合和該集合中資料元素之間的關係組成 。 常用的資料結構有：陣列，棧，連結串列，佇列，樹，圖，堆，散列表等，如圖所示：

計算機專業保研面試複習筆記——資料結構中的重要演算法

字串匹配 KMP演算法 判斷模式串是否是主串的子串 對模式串的字元特點，求得next陣列。next[i]代表如果第i位匹配失敗，應該向後移動幾位。時間複雜度O(m+n)，即主串長度+模式串長度。是一種空間換時間的演算

三年開發拿阿里P6+offer：基礎+資料結構+JVM+設計模式+演算法+多執行緒+分散式+網路

前言 工作三年有餘，第一份工作是在一家外包公司，第二份工作是在一家做SAAS平臺的公司，第一家公司讓我入門，進入了軟體開發的行業，瞭解了一些基礎的東西；第二家公司由於規模不大，很多活兒都是一個人來做，從產品

一文看懂C語言經典八大排序演算法，動圖加程式碼！不怕學不會！

一、前言 如果說各種程式語言是程式設計師的招式，那麼資料結構和演算法就相當於程式設計師的內功。

資料結構之插入排序（Java）

1、基本思想 依次取出陣列中的元素，將其插入到已經排好序的元素序列中，得到一個新的、排好序的陣列。即每一步將一個數據插入到前面已經排好序的陣列中，直到全部插入完為止。

資料結構實驗之排序四：尋找大富翁

資料結構實驗之排序四：尋找大富翁 Code: 1 #include <bits/stdc++.h> 2 using namespace std;

八大排序演算法-初學筆記

八大經典排序 　　 1、氣泡排序 基本介紹：氣泡排序是一種交換排序 基本思想：（假定從小到大的順序）從第一個元素開始，相鄰兩個資料進行比較，將小的值放在左邊。第一輪：從第一個元素開始，和與其相鄰的後一個

資料結構之堆排序(二)

技術標籤：Java資料結構資料結構排序演算法堆排序二叉樹 馬不停蹄,堆上昨晚 ---------堆的程式碼

D - 資料結構實驗之排序四：尋找大富翁

技術標籤：《資料結構》8排序 Description 2015胡潤全球財富榜調查顯示，個人資產在1000萬以上的高淨值人群達到200萬人，假設給出N個人的個人資產值，請你快速找出排前M位的大富翁。 Input