七大經典排序算法小結

時間  2020-01-22
標籤 七大 經典 排序算法 小結 简体版
原文   原文鏈接

前言

前端面試和筆試中被問到最多的算法可能就是各類排序算法了，算法並不難，平時常常用到，但不少時候不多會去認真考慮算法優劣性和適應場景，真正一個一個去分析也須要花很多時時間，因此趁年底有空，不如再複習一遍排序算法。javascript

全部排序算法讀者可自行嘗試coding，想看源碼戳這裏。此文配合源碼體驗更佳！html

排序算法評價標準

時間複雜度

一個算法語句總的執行次數是關於問題規模N的某個函數，記爲f(N)，N稱爲問題的規模。語句總的執行次數記爲T(N)，當N不斷變化時，T(N)也在變化，算法執行次數的增加速率和f(N)的增加速率相同。前端

則有T(N) = O(f(N))，這稱做算法的漸進時間複雜度，簡稱時間複雜度。java

最壞時間複雜度、最好時間複雜度和平均時間複雜度

最壞時間複雜度
最壞狀況下的時間複雜度稱最壞時間複雜度，通常不特別說明，討論的時間複雜度均是最壞狀況下的時間複雜度。這樣作的緣由是：最壞狀況下的時間複雜度是算法在任何輸入實例上運行時間的上界，這就保證了算法的運行時間不會比任何更長。 git

平均時間複雜度
平均時間複雜度是指全部可能的輸入實例均以等機率出現的狀況下，算法的指望運行時間，設每種狀況的出現的機率爲pi,平均時間複雜度則爲sum(pi*f(n)) 。github

最好時間複雜度
最理想狀況下的時間複雜度稱最好時間複雜度。面試

空間複雜度

空間複雜度(Space Complexity)是對一個算法在運行過程當中臨時佔用存儲空間大小的量度，記作S(n)=O(f(n))。算法

穩定性

穩定的算法在排序的過程當中不會改變元素彼此的位置的相對次序，反之不穩定的排序算法常常會改變這個次序,這是咱們不肯意看到的。shell

咱們在使用排序算法或者選擇排序算法時,更但願這個次序不會改變,更加穩定,因此排序算法的穩定性,是一個特別重要的參數衡量指標依據。segmentfault

內排序、外排序

內排序：全部排序操做都在內存中完成，適用於數據規模不是特別大的狀況；
外排序：因爲數據太大，所以把數據放在磁盤中，而排序經過磁盤和內存的數據傳輸才能進行；

各排序算法總結

對算法原理很熟悉的同窗能夠直接記憶這張表。

排序算法分析.jpeg
圖片名詞解釋：

  • n: 數據規模
  • k:「桶」的個數
  • In-place: 佔用常數內存，不佔用額外內存
  • Out-place: 佔用額外內存

1、冒泡排序（Bubble Sort）

算法描述

冒泡排序是一種簡單的排序算法。它重複地走訪過要排序的數列，一次比較兩個相鄰元素，若是它們的順序錯誤就把它們交換過來。走訪數列的工做是重複地進行直到沒有再須要交換，也就是說該數列已經排序完成。這個算法的名字由來是由於越小的元素會經由交換慢慢「浮」到數列的頂端。

算法思路

具體算法描述以下：

  1. 比較相鄰的元素。若是第一個比第二個大，就交換它們兩個；
  2. 對每一對相鄰元素做一樣的工做，從開始第一對到結尾的最後一對，這樣在最後的元素應該會是最大的數；
  3. 針對全部的元素重複以上的步驟，除了最後一個；
  4. 重複步驟1~3，直到數組有序，排序完成。

算法實現

let bubbleSort = arr => {
  for (let i = 0; i < arr.length; i++) {
    for (let j = 0; j < arr.length - i - 1; j++) {
      if (arr[j] > arr[j + 1]) {
        let temp = arr[j];
        arr[j] = arr[j + 1];
        arr[j + 1] = temp;
      }
    }
  }
  return arr;
};

算法分析

平均時間複雜度: T(n) = O(n²)
最壞時間複雜度: T(n) = O(n²)：當輸入的數據是反序時
最好時間複雜度: T(n) = O(n)：當輸入的數據已經有序時，只需遍歷一遍用於確認數據已有序。
空間複雜度: O(1)
穩定性: 穩定

算法改進思路

  1. 改進思路一：設置一標誌flag，當一趟遍歷過程當中發生元素交換時改變flag值，而某趟當flag值沒有改變，則表明數組已經有序，無需再繼續排序。
  2. 改進思路二： 設置一標誌性變量pos，用於記錄每趟排序中最後一次進行交換的位置。因爲pos位置以後的記錄均已交換到位,故在進行下一趟排序時只要掃描到pos位置便可。
  3. 改進思路三：傳統冒泡排序中每一趟排序操做只能找到一個最大值或最小值,咱們考慮利用在每趟排序中進行正向和反向兩遍冒泡的方法一次能夠獲得兩個最終值(最大者和最小者) , 從而使排序趟數幾乎減小了一半。

算法動圖演示

冒泡排序.gif

2、簡單選擇排序（insertion Sort）

算法描述

選擇排序(Selection-sort)是一種簡單直觀的排序算法。它的工做原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，而後，再從剩餘未排序元素中繼續尋找最小（大）元素，而後放到已排序序列的末尾。以此類推，直到全部元素均排序完畢。

算法思路

具體算法描述以下：
n個記錄的直接選擇排序可通過n-1趟直接選擇排序獲得有序結果。具體算法描述以下：

  1. 初始狀態：無序區爲R[1..n]，有序區爲空；
  2. 第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個的新無序區；
  3. n-1趟結束，數組有序化了。

算法實現

let selectSort = arr => {
  for (let i = 0; i < arr.length; i++) {
    Let min = arr[i]; // 初始化最小值爲第一個元素
    let index = i; // 最小值下標
    for (let j = i + 1; j < arr.length; j++) {
      if (arr[j] < min) { // 發現更小的數則交換位置
        min = arr[j];
        index = j;
      }
    }
    // 將當前趟最小值移動至其最終位置
    let temp = arr[i];
    arr[i] = min;
    arr[index] = temp;
  }
};

算法分析

選擇排序是時間複雜度表現最穩定的排序算法之一，不管什麼數據進去都是O(n²) 的時間複雜度…..因此用到它的時候，數據規模越小越好。這也是通常人想到最多的簡單算法，簡單粗暴。
平均時間複雜度: T(n) = O(n²)
最壞時間複雜度: T(n) = O(n²)
最好時間複雜度: T(n) = O(n²)
空間複雜度: O(1)
穩定性: 不穩定

算法改進思路

性能表現實在太穩定了，通常改進思路能夠從空間換時間角度切入，減小比較次數。

算法動圖演示

選擇排序.gif

3、插入排序

算法描述

插入排序（insertion-Sort）的算法描述是一種簡單直觀的排序算法。它的工做原理是經過構建有序序列，對於未排序數據，在已排序序列中從後向前掃描，找到相應位置並插入。插入排序在實現上，一般採用in-place排序（即只需用到O(1)的額外空間的排序），於是在從後向前掃描過程當中，須要反覆把已排序元素逐步向後挪位，爲最新元素提供插入空間。

若是你會打撲克牌，你在抓牌整理牌時，已經無心識地用到了插入排序。

算法思路

通常來講，插入排序都採用in-place在數組上實現。具體算法描述以下：

  1. 從第一個元素開始，該元素能夠認爲已經被排序；
  2. 取出下一個元素，在已經排序的元素序列中從後向前掃描；
  3. 若是該元素（已排序）大於新元素，將該元素移到下一位置；
  4. 重複步驟3，直到找到已排序的元素小於或者等於新元素的位置；
  5. 將新元素插入到該位置後；
  6. 重複步驟2~5。

算法實現

let insertSort = arr => {
  for (let i = 1; i < arr.length; i++) {
    let key = arr[i];
    let j = i - 1;
    while (j >= 0 && arr[j] > key) {
      arr[j + 1] = arr[j];
      j--;
    }
    arr[j + 1] = key;
  }
  return arr;
};

算法分析

平均時間複雜度: T(n) = O(n²)
最壞時間複雜度: T(n) = O(n²)：輸入數組按降序排列（徹底逆序）
最好時間複雜度: T(n) = O(n)：輸入數組按升序排列（基本有序）
空間複雜度: O(1)
穩定性：穩定

算法改進思路

  1. 改進思路一：查找插入位置時使用二分查找的方式，減小比較次數。

算法動圖演示

插入排序.gif

4、希爾排序

算法描述

1959年Shell發明； 第一個突破O(n²)的排序算法；是簡單插入排序的改進版；它與插入排序的不一樣之處在於，它會優先比較距離較遠的元素。希爾排序又叫縮小增量排序

算法思路

該方法實質上是一種分組插入方法，希爾排序是基於插入排序的如下兩點性質而提出改進方法的：

  • 插入排序在對幾乎已經排好序的數據操做時，效率高，便可以達到線性排序的效率。
  • 但插入排序通常來講是低效的，由於插入排序每次只能將數據移動一位。

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

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

算法實現

let shellSort = function (arr) {
  let len = arr.length, temp, gap = 1;
  // 動態定義間隔序列
  while (gap < len / 5) {
    gap = gap * 5 + 1;
  }
  for (gap; gap > 0; gap = Math.floor(gap / 5)) {
    for (let i = gap; i < len; i++) {
      temp = arr[i];
      for (let j = i - gap; j >= 0 && arr[j] > temp; j -= gap) {
        arr[j + gap] = arr[j];
      }
      arr[j + gap] = temp;
    }
  }
  return arr;
}

算法分析

  • 平均時間複雜度：T(n) = O(n^1.5)
  • 最壞時間複雜度：T(n) = O(nlog²n）
  • 空間複雜度: O(1)
  • 穩定性: 不穩定，因爲屢次插入排序，咱們知道一次插入排序是穩定的，不會改變相同元素的相對順序，但在不一樣的插入排序過程當中，相同的元素可能在各自的插入排序中移動，最後其穩定性就會被打亂，因此shell排序是不穩定的。

算法改進思路

Shell排序的執行時間依賴於增量序列，好的增量序列的共同特徵：
① 最後一個增量必須爲1；
② 應該儘可能避免序列中的值(尤爲是相鄰的值)互爲倍數的狀況。
有人經過大量的實驗，給出了較好的結果：當n較大時，比較和移動的次數約在nl.25到1.6n1.25之間。

可是Shell排序的時間性能顯然優於直接插入排序，希爾排序的時間性能優於直接插入排序的緣由：

  1. 當文件初態基本有序時直接插入排序所需的比較和移動次數均較少。
  2. 當n值較小時，n 和 n² 的差異也較小，即直接插入排序的最好時間複雜度 O(n) 和最壞時間複雜度 O(n²) 差異不大。
  3. 在希爾排序開始時增量較大，分組較多，每組的記錄數目少，故各組內直接插入較快，後來增量di逐漸縮小，分組數逐漸減小，而各組的記錄數目逐漸增多，但因爲已經按di-1做爲距離排過序，使文件較接近於有序狀態，因此新的一趟排序過程也較快。

所以，希爾排序在效率上較直接插入排序有較大的改進。

使用建議：

不須要大量的輔助空間，和歸併排序同樣容易實現。希爾排序是基於插入排序的一種算法， 在此算法基礎之上增長了一個新的特性，提升了效率。希爾排序沒有快速排序算法快 O(n(logn))，所以中等大小規模表現良好，對規模很是大的數據排序不是最優選擇。可是比O(n²)複雜度的算法快得多。而且希爾排序很是容易實現，算法代碼短而簡單。 此外，希爾算法在最壞的狀況下和平均狀況下執行效率相差不是不少，與此同時快速排序在最壞的狀況下執行的效率會很是差。專家們提倡，幾乎任何排序工做在開始時均可以用希爾排序，若在實際使用中證實它不夠快，再改爲快速排序這樣更高級的排序算法

算法演示

希爾排序.jpg

5、歸併排序

算法描述

和選擇排序同樣，歸併排序的性能不受輸入數據的影響，但表現比選擇排序好的多，由於始終都是O(n log^n）的時間複雜度。代價是須要額外的內存空間。
歸併排序是創建在歸併操做上的一種有效的排序算法。該算法是採用分治法（Divide and Conquer）的一個很是典型的應用。歸併排序是一種穩定的排序方法。將已有序的子序列合併，獲得徹底有序的序列；即先使每一個子序列有序，再使子序列段間有序。若將兩個有序表合併成一個有序表，稱爲2-路歸併。

算法思路

歸併排序算法思想：分而治之：

  • 分解：把長度爲n 的待排序列分解成 兩個長度爲n/2 的序列
  • 治理：對每一個子序列分別調用歸併排序，進行遞歸操做。當子序列長度爲1 時，序列自己有序，中止遞歸
  • 合併：合併每一個排序好的子序列

算法實現

let merge = (left, right) => {
  let result = [];
  while (left.length && right.length) {
    if (left[0] <= right[0]) {
      result.push(left.shift());
    } else {
      result.push(right.shift());
    }
  }
  while (left.length) {
    result.push(left.shift());
  }
  while (right.length) {
    result.push(right.shift());
  }
  return result;
}

//採用自上而下的遞歸方法
let mergeSort = arr => {
  let len = arr.length;
  if (len < 2) {
    return arr;
  }
  let middle = Math.floor(len / 2),
    left = arr.slice(0, middle),
    right = arr.slice(middle);
  return merge(mergeSort(left), mergeSort(right));
}

算法分析

  • 平均狀況：T(n) = O(nlogn)
  • 最差狀況：T(n) = O(nlogn)
  • 最佳狀況：T(n) = O(n)
  • 空間複雜度: O(n)，歸併排序須要一個與原數組相同長度的數組作輔助來排序
  • 穩定性: 穩定

算法改進思路

  1. 對小規模子數組使用插入排序。用不一樣的方法處理小規模數組能改進大多遞歸算法的性能，在小數組上上，插入排序可能比並歸排序更快。
  2. 測試數組是否有序。根據歸併排序的特色，每次歸併的兩個小數組都是有序的，當 a[mid] <= a[mid + 1]時咱們能夠跳過merge方法，這樣並不影響排序的遞歸調用。
  3. 不將元素複製到輔助數組。咱們能夠節省將數組複製到輔助數組的時間，這須要一些技巧。先克隆原數組到輔助數組，而後在以後的遞歸交換輸入數組和輔助數組的角色（經過看代碼更容易理解）

算法動圖演示

歸併排序.gif

6、快速排序

快速排序的名字起的是簡單粗暴，由於一聽到這個名字你就知道它存在的意義，就是快，並且效率高! 它是處理大數據最快的排序算法之一了。

算法描述

快速排序的基本思想：經過一趟排序將待排記錄分隔成獨立的兩部分，其中一部分記錄的關鍵字均比另外一部分的關鍵字小，則可分別對這兩部分記錄繼續進行排序，以達到整個序列有序。

算法思路

快速排序使用分治法來把一個串（list）分爲兩個子串（sub-lists）。具體算法描述以下：

  1. 從數列中挑出一個元素，稱爲 "基準"（pivot）；
  2. 從新排序數列，全部元素比基準值小的擺放在基準前面，全部元素比基準值大的擺在基準的後面（相同的數能夠到任一邊）。在這個分區退出以後，該基準就處於數列的中間位置。這個稱爲分區（partition）操做；
  3. 遞歸地（recursive）把小於基準值元素的子數列和大於基準值元素的子數列排序。

算法實現

方法一：

let quickSort = (array, left, right) => {
  if (Array.isArray(array) && typeof left === 'number' && typeof right === 'number') {
    if (left < right) {
      let x = array[right], i = left - 1, temp;
      for (let j = left; j <= right; j++) {
        if (array[j] <= x) {
          i++;
          temp = array[i];
          array[i] = array[j];
          array[j] = temp;
        }
      }
      quickSort(array, left, i - 1);
      quickSort(array, i + 1, right);
    }
    return array;
  } else {
    return 'array is not an Array or left or right is not a number!';
  }
}

方法二

let quickSort2 = arr => {
  if (arr.length < 2) {
    return arr;
  }
  let pivotindex = Math.floor(arr.length / 2);
  let pivot = arr.splice(pivotindex, 1)[0];
  let left = [];
  let right = [];
  for (let i = 0; i < arr.length; i++) {
    if (arr[i] < pivot) {
      left.push(arr[i]);
    } else {
      right.push(arr[i]);
    }
  }
  return quickSort2(left).concat([pivot], quickSort2(right));
};

算法分析

  • 最佳狀況：T(n) = O(nlogn)，快速排序最優的狀況就是每一次取到的元素都恰好平分整個數組
  • 最差狀況：T(n) = O(n²)，最差的狀況就是每一次取到的元素就是數組中最小/最大的，這種狀況其實就是冒泡排序了(每一次都排好一個元素的順序)
  • 平均狀況：T(n) = O(nlogn)
  • 穩定性：不穩定

算法改進思路

改進思路：改進選取樞軸的方法

  1. 選取隨機數做爲樞軸。可是隨機數的生成自己是一種代價，根本減小不了算法其他部分的平均運行時間。
  2. 使用左端，右端和中心的中值作爲樞軸元。經驗得知，選取左端，右端，中心元素的中值會減小了快排大約 14%的比較。
  3. 每次選取數據集中的中位數作樞軸。選取中位數的能夠在 O(n)時間內完成。（證實見《算法導論（第二版）》） P111 第九章中位數和順序統計學：在平均狀況下，任何順序統計量（特別是中位數）均可以在線性時間內獲得。

其餘改進思路：

  1. 快速排序在處理小規模數據時的表現很差。這個時候能夠改用插入排序。當數據規模小於必定程度時，改用插入排序。具體小到何種規模時，採用插入排序，這個理論上還不解，一些文章中說是 5 到 25 之間。SGI STL 中的快速排序採用的值是 10。
  2. 對於一個每一個元素都徹底相同的一個序列來說，快速排序也會退化到 O(n²)。要將這種狀況避免到，能夠這樣作：在分區的時候，將序列分爲 3 堆，一堆小於中軸元素，一堆等於中軸元素，一堆大於中軸元素，下次遞歸調用快速排序的時候，只需對小於和大於中軸元素的兩堆數據進行排序，中間等於中軸元素的一堆已經放好

算法動圖演示

快速排序.gif

7、堆排序

堆排序能夠說是一種利用堆的概念來排序的選擇排序。

算法描述

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

算法思路

具體算法描述以下：

  1. 將初始待排序關鍵字序列(R1,R2….Rn)構建成大頂堆，此堆爲初始的無序區；
  2. 將堆頂元素R[1]與最後一個元素R[n]交換，此時獲得新的無序區(R1,R2,……Rn-1)和新的有序區(Rn),且知足R[1,2…n-1]<=R[n]；
  3. 因爲交換後新的堆頂R[1]可能違反堆的性質，所以須要對當前無序區(R1,R2,……Rn-1)調整爲新堆，而後再次將R[1]與無序區最後一個元素交換，獲得新的無序區(R1,R2….Rn-2)和新的有序區(Rn-1,Rn)。不斷重複此過程直到有序區的元素個數爲n-1，則整個排序過程完成。

算法實現

/*方法說明：堆排序
@param  array 待排序數組*/
function heapSort(array) {
    console.time('堆排序耗時');
    if (Object.prototype.toString.call(array).slice(8, -1) === 'Array') {
        //建堆
        var heapSize = array.length, temp;
        for (var I = Math.floor(heapSize / 2) - 1; I >= 0; I—) {
            heapify(array, I, heapSize);
        }

        //堆排序
        for (var j = heapSize - 1; j >= 1; j—) {
            temp = array[0];
            array[0] = array[j];
            array[j] = temp;
            heapify(array, 0, —heapSize);
        }
        console.timeEnd('堆排序耗時');
        return array;
    } else {
        return 'array is not an Array!';
    }
}
/*方法說明：維護堆的性質
@param  arr 數組
@param  x   數組下標
@param  len 堆大小*/
function heapify(arr, x, len) {
    if (Object.prototype.toString.call(arr).slice(8, -1) === 'Array' && typeof x === 'number') {
        var l = 2 * x + 1, r = 2 * x + 2, largest = x, temp;
        if (l < len && arr[l] > arr[largest]) {
            largest = l;
        }
        if (r < len && arr[r] > arr[largest]) {
            largest = r;
        }
        if (largest != x) {
            temp = arr[x];
            arr[x] = arr[largest];
            arr[largest] = temp;
            heapify(arr, largest, len);
        }
    } else {
        return 'arr is not an Array or x is not a number!';
    }
}

算法分析

調堆：O(h)
建堆：O(n)
循環調堆：O(nlogn)
總運行時間T(n) = O(nlogn) + O(n) = O(nlogn)。對於堆排序的最好狀況與最壞狀況的運行時間，由於最壞與最好的輸入都只是影響建堆的運行時間O(1)或者O(n)，而在整體時間中佔重要比例的是循環調堆的過程，即O(nlogn) + O(1) =O(nlogn) + O(n) = O(nlogn)。所以最好或者最壞狀況下，堆排序的運行時間都是O(nlogn)。並且堆排序仍是 原地算法（in-place algorithm） 。

  • 平均狀況：T(n) = O(nlogn)
  • 最差狀況：T(n) = O(nlogn)
  • 最佳狀況：T(n) = O(nlogn)
  • 空間複雜度：O(1)
  • 穩定性：不穩定

算法動圖演示

堆排序.gif

小結

文章最後再對七大經典排序算法性能分析作一次小結，加深記憶。

穩定的排序：冒泡排序，插入排序，歸併排序
不穩定的排序：選擇排序，堆排序，快速排序，希爾排序

平均時間複雜度T(n) = O(nlogn)：希爾排序，歸併排序，快速排序，堆排序
平均時間複雜度T(n) = O(n²)：冒泡排序，簡單選擇排序，插入排序

最好時間複雜度T(n) = O(n)：冒泡排序，插入排序
最好時間複雜度T(n) = O(nlogn)：歸併排序，快速排序，堆排序
最好時間複雜度T(n) = O(n²)：簡單選擇排序

最壞時間複雜度T(n) = O(nlogn)：歸併排序，堆排序
最壞時間複雜度T(n) = O(n²)：冒泡排序，簡單選擇排序，插入排序，快速排序

空間複雜度O(1)：冒泡排序，簡單選擇排序，插入排序，希爾排序，堆排序
空間複雜度O(n)：歸併排序
空間複雜度O(nlogn)：快速排序

參考：
十大經典排序算法總結
堆排序及其分析

推薦閱讀：
【專題：JavaScript進階之路】
TCP三次握手和四次揮手
AJAX原理及常見面試題
ES6 尾調用和尾遞歸
JavaScript之函數柯理化
淺談 MVC 和 MVVM 模型

我是Cloudy，年輕的前端攻城獅一枚，愛專研，愛技術，愛分享。
我的筆記，整理不易，感謝關注、閱讀、點贊和收藏。
文章有任何問題歡迎你們指出，也歡迎你們一塊兒交流各類技術問題！
最後，Base上海，正在尋找新的工做機會中(^-^)，提早祝你們新年快樂！
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程