簡述幾種常用的排序演算法

華為雲開發者聯盟發表於2023-03-27
摘要:歸併排序和快速排序是兩種稍微複雜的排序演算法,它們用的都是分治的思想,程式碼都透過遞迴來實現,過程非常相似。理解歸併排序的重點是理解遞推公式和 merge() 合併函式。

本文分享自華為雲社群《深入淺出八種排序演算法》,作者:嵌入式視覺 。

歸併排序和快速排序是兩種稍微複雜的排序演算法,它們用的都是分治的思想,程式碼都透過遞迴來實現,過程非常相似。理解歸併排序的重點是理解遞推公式和 merge() 合併函式。

一,氣泡排序(Bubble Sort)

排序演算法是程式設計師必須瞭解和熟悉的一類演算法,排序演算法有很多種,基礎的如:冒泡、插入、選擇、快速、歸併、計數、基數和桶排序等。

氣泡排序只會操作相鄰的兩個資料。每次冒泡操作都會對相鄰的兩個元素進行比較,看是否滿足大小關係要求,如果不滿足就讓它倆互換。一次冒泡會讓至少一個元素移動到它應該在的位置,重複 n 次,就完成了 n 個資料的排序工作。

總結:如果陣列有 n 個元素,最壞情況下,需要進行 n 次冒泡操作。

基礎的氣泡排序演算法的 C++ 程式碼如下:

// 將資料從小到大排序
void bubbleSort(int array[], int n){
 if (n<=1) return;
 for(int i=0; i<n; i++){
 for(int j=0; j<n-i; j++){
 if (temp > a[j+1]){
                temp = array[j]
                a[j] = a[j+1];
                a[j+1] = temp;
 }
 }
 }
}

實際上,以上的氣泡排序演算法還可以最佳化,當某次冒泡操作已經不再進行資料交換時,說明陣列已經達到有序,就不需要再繼續執行後續的冒泡操作了。最佳化後的程式碼如下:

// 將資料從小到大排序
void bubbleSort(int array[], int n){
 if (n<=1) return;
 for(int i=0; i<n; i++){
 // 提前退出冒泡迴圈發標志位
        bool flag = False;
 for(int j=0; j<n-i; j++){
 if (temp > a[j+1]){
                temp = array[j]
                a[j] = a[j+1];
                a[j+1] = temp;
                flag = True; // 表示本次冒泡操作存在資料交換
 }
 }
 if(!flag) break; // 沒有資料交換,提交退出
 }
}

氣泡排序的特點:

  1. 冒泡過程只涉及相鄰元素的交換,只需要常量級的臨時空間,故空間複雜度為 O(1)O(1),是原地排序演算法
  2. 當有相鄰的兩個元素大小相等的時候,我們不做交換,相同大小的資料在排序前後不會改變順序,所以是穩定排序演算法
  3. 最壞情況和平均時間複雜度都為 O(n2)O(n2),最好時間複雜度是 O(n)O(n)。

二,插入排序(Insertion Sort)

  1. 插入排序演算法將陣列中的資料分為兩個區間:已排序區間和未排序區間。最初始的已排序區間只有一個元素,就是陣列的第一個元素。
  2. 插入排序演算法的核心思想就是取未排序區間的一個元素,在已排序區間中找到一個合適的位置插入,並保證已排序區間資料一直有序。
  3. 重複這個過程,直到未排序區間元素為空,則演算法結束。

插入排序和氣泡排序一樣,也包含兩種操作,一種是元素的比較,一種是元素的移動

當我們需要將一個資料 a 插入到已排序區間時,需要拿 a 與已排序區間的元素依次比較大小,找到合適的插入位置。找到插入點之後,我們還需要將插入點之後的元素順序往後移動一位,這樣才能騰出位置給元素 a 插入。

插入排序的 C++ 程式碼實現如下:

void InsertSort(int a[], int n){
 if (n <= 1) return;
 for (int i = 1; i < n; i++) // 未排序區間範圍
 {
        key  = a[i]; // 待排序第一個元素
        int j = i - 1; // 已排序區間末尾元素
 // 從尾到頭查詢插入點方法
 while(key < a[j] && j >= 0){ // 元素比較
            a[j+1] = a[j]; // 資料向後移動一位
            j--;
 }
        a[j+1] = key; // 插入資料
 }
}

插入排序的特點:

  1. 插入排序並不需要額外儲存空間,空間複雜度是 O(1)O(1),所以插入排序也是一個原地排序演算法。
  2. 在插入排序中,對於值相同的元素,我們可以選擇將後面出現的元素,插入到前面出現元素的後面,這樣就可以保持原有的前後順序不變,所以插入排序是穩定的排序演算法。
  3. 最壞情況和平均時間複雜度都為 O(n2)O(n2),最好時間複雜度是 O(n)O(n)。

三,選擇排序(Selection Sort)

選擇排序演算法的實現思路有點類似插入排序,也分已排序區間和未排序區間。但是選擇排序每次會從未排序區間中找到最小的元素,將其放到已排序區間的末尾。

選擇排序的最好情況時間複雜度、最壞情況和平均情況時間複雜度都為 O(n2)O(n2),是原地排序演算法,且是不穩定的排序演算法

選擇排序的 C++ 程式碼實現如下:

void SelectSort(int a[], int n){
 for(int i=0; i<n; i++){
        int minIndex = i;
 for(int j = i;j<n;j++){
 if (a[j] < a[minIndex]) minIndex = j;
 }
 if (minIndex != i){
            temp = a[i]; 
            a[i] = a[minIndex];
            a[minIndex] = temp;
 }
 }
}

冒泡插入選擇排序總結

簡述幾種常用的排序演算法

這三種排序演算法,實現程式碼都非常簡單,對於小規模資料的排序,用起來非常高效。但是在大規模資料排序的時候,這個時間複雜度還是稍微有點高,所以更傾向於用時間複雜度為 O(nlogn)O(nlogn) 的排序演算法。

特定演算法是依賴特定的資料結構的。以上三種排序演算法,都是基於陣列實現的。

四,歸併排序(Merge Sort)

歸併排序的核心思想比較簡單。如果要排序一個陣列,我們先把陣列從中間分成前後兩部分,然後對前後兩部分分別排序,再將排好序的兩部分合並在一起,這樣整個陣列就都有序了。

歸併排序使用的是分治思想。分治,顧名思義,就是分而治之,將一個大問題分解成小的子問題來解決。小的子問題解決了,大問題也就解決了。

分治思想和遞迴思想有些類似,分治演算法一般用遞迴實現。分治是一種解決問題的處理思想,遞迴是一種程式設計技巧,這兩者並不衝突。

知道了歸併排序用的是分治思想,而分治思想一般用遞迴實現,接下來的重點就是如何用遞迴實現歸併排序。寫遞迴程式碼的技巧就是,分析問題得出遞推公式,然後找到終止條件,最後將遞推公式翻譯成遞迴程式碼。所以,要想寫出歸併排序的程式碼,得先寫出歸併排序的遞推公式

遞推公式:
merge_sort(p…r) = merge(merge_sort(p…q), merge_sort(q+1…r))
終止條件:
p >= r 不用再繼續分解,即區間陣列元素為 1 

歸併排序的虛擬碼如下:

merge_sort(A, n){
 merge_sort_c(A, 0, n-1)
}
merge_sort_c(A, p, r){
 // 遞迴終止條件
 if (p>=r) then return
 // 取 p、r 中間的位置為 q
    q = (p+r)/2
 // 分治遞迴
 merge_sort_c(A[p, q], p, q)
 merge_sort_c(A[q+1, r], q+1, r)
 // 將A[p...q]和A[q+1...r]合併為A[p...r]  
 merge(A[p...r], A[p...q], A[q+1...r])
}

4.1,歸併排序效能分析

1,歸併排序是一個穩定的排序演算法。分析:虛擬碼中 merge_sort_c() 函式只是分解問題並沒有涉及移動元素和比較大小,真正的元素比較和資料移動在 merge() 函式部分。在合併過程中保證值相同的元素合併前後的順序不變,歸併排序排序就是一個穩定的排序演算法。

2,歸併排序的執行效率與要排序的原始陣列的有序程度無關,所以其時間複雜度是非常穩定的,不管是最好情況、最壞情況,還是平均情況,時間複雜度都是 O(nlogn)O(nlogn)。分析:不僅遞迴求解的問題可以寫成遞推公式,遞迴程式碼的時間複雜度也可以寫成遞推公式:

簡述幾種常用的排序演算法

3,空間複雜度是 O(n)。分析:遞迴程式碼的空間複雜度並不能像時間複雜度那樣累加。儘管演算法的每次合併操作都需要申請額外的記憶體空間,但在合併完成之後,臨時開闢的記憶體空間就被釋放掉了。在任意時刻,CPU 只會有一個函式在執行,也就只會有一個臨時的記憶體空間在使用。臨時記憶體空間最大也不會超過 n 個資料的大小,所以空間複雜度是 O(n)O(n)。

五,快速排序(Quicksort)

快排的思想是這樣的:如果要排序陣列中下標從 p 到 r 之間的一組資料,我們選擇 p 到 r 之間的任意一個資料作為 pivot(分割槽點)。我們遍歷 p 到 r 之間的資料,將小於 pivot 的放到左邊,將大於 pivot 的放到右邊,將 pivot 放到中間。經過這一步驟之後,陣列 p 到 r 之間的資料就被分成了三個部分,前面 p 到 q-1 之間都是小於 pivot 的,中間是 pivot,後面的 q+1 到 r 之間是大於 pivot 的。

根據分治、遞迴的處理思想,我們可以用遞迴排序下標從 p 到 q-1 之間的資料和下標從 q+1 到 r 之間的資料,直到區間縮小為 1,就說明所有的資料都有序了。

遞推公式如下:

遞推公式:
quick_sort(p,r) = quick_sort(p, q-1) + quick_sort(q, r)
終止條件:
p >= r

歸併排序和快速排序總結

歸併排序和快速排序是兩種稍微複雜的排序演算法,它們用的都是分治的思想,程式碼都透過遞迴來實現,過程非常相似。理解歸併排序的重點是理解遞推公式和 merge() 合併函式。同理,理解快排的重點也是理解遞推公式,還有 partition() 分割槽函式。

除了以上 5 種排序演算法,還有 3 種時間複雜度是 O(n)O(n) 的線性排序演算法:桶排序、計數排序、基數排序。這八種排序演算法效能總結如下圖:

簡述幾種常用的排序演算法

參考資料

  • 排序(上):為什麼插入排序比氣泡排序更受歡迎?
  • 排序(下):如何用快排思想在O(n)內查詢第K大元素?

 

點選關注,第一時間瞭解華為雲新鮮技術~

相關文章