花費了幾周的時間斷斷續續的練習和模仿與使用JavaScript程式碼實現了十大排序演算法。

裡面有每種演算法的動圖和靜態圖片演示，看到圖片可以自己先按照圖片的思路實現一下。

github中正文連結，點選檢視

兩年前端學習筆記：https://github.com/zhangyachang/Notes 歡迎點個star

排序演算法說明

1.氣泡排序(Bubble Sort) 　　1.演算法描述    2.演算法描述和實現    3.氣泡排序動圖演示

2.選擇排序（Selection Sort    1.演算法簡介     2.演算法描述和實現     3.選擇排序動圖演示

3.插入排序(Insertion Sort)     1.演算法簡介     2.演算法的描述和實現     3.插入排序動圖演示

4.希爾排序(Shell Sort)     1.演算法簡介     2.演算法描述和實現     3.希爾排序圖示

5.歸併排序(Merge Sort)     1.演算法簡介      2.演算法描述和實現     3.歸併排序動圖演示

6.快速排序(Quick Sort)     1.演算法簡介     2.演算法描述和實現     3.快速排序動圖演示

7.堆排序（Heap Sort）     1.演算法簡介     2.演算法描述和實現      3.堆排序動圖演示

8.計數排序(Counting Sort)     1.演算法簡介     2.演算法描述和實現     3.計數排序動圖演示

9.桶排序（Bucket Sort）     1.演算法簡介     2.演算法描述和實現     3.桶排序圖示

10.基數排序（Radix Sort）     1.演算法簡介     2.演算法描述和實現     3.基數排序動圖演示後記

排序演算法說明

1.排序的定義

對一序列物件根據某個關鍵字進行排序

輸入：n個數：a1,a2,a3,...,an 輸出：n個數的排列:a1',a2',a3',...,an'，使得a1'<=a2'<=a3'<=...<=an'。

再講的形象點就是排排坐，調座位，高的站後面，矮的站前面。

2.對於評述演算法優劣術語的說明

穩定：如果a原本在b前面，而a=b,排序之後a仍然在b的前面；不穩定：如果a原本在b的前面，而a=b，排序之後a可能會出現在b的後面；

內排序：所有排序操作都在記憶體中完成；外排序：由於資料太大，因此把資料放在磁碟中，而排序通過磁碟和記憶體的資料傳輸才能進行；

時間複雜度：一個演算法執行所耗費的時間。空間複雜度：執行完一個程式所需記憶體的大小。

3.排序演算法圖片總結

圖片名詞解釋：n：資料規模 k 桶的個數 in-place：佔用常數記憶體，不佔用額外記憶體 Out-place：佔用額外記憶體。

1.氣泡排序(Bubble Sort)

好的，開始總結第一個排序演算法，氣泡排序。我想對於它每個學過C語言的都會了解的吧，這可能是很多人接觸的第一個排序演算法。

1.演算法描述

氣泡排序是一種簡單的排序演算法。它重複的走訪過要排序的數列，一次比較兩個元素，如果它們的順序錯誤就把它們交換過來。走訪數列的工作是重複的進行直到沒有再需要交換，也就是說該數列已經排序完成。這個演算法的名字由來是因為越小的元素會經由交換慢慢”浮“到數列的頂端。

2.演算法描述和實現

具體的演算法描述如下

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

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

• <3>.針對所有的元素重複以上的操作，除了最後一個；

• <4>.重複步驟1~3，直到排序完成。

JavaScript程式碼實現：

function bubbleSort(arr) {
  let len = arr.length;

  for (let i = 0; i < len; i++) {
    for (let j = 0; j < len - i - 1; j++) {
      if (arr[j] > arr[j + 1]) {  // 相鄰元素兩兩對比
        let tmp = arr[j];         // 元素交換
        arr[j] = arr[j + 1];
        arr[j + 1] = tmp;
      }
    }
  }

  return arr;
}

let arr = [3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48];
console.log(bubbleSort(arr));
// [2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 48, 50]

改進氣泡排序：設定一標誌性變數post，用於記錄每趟排序中最後一次交換的位置。由於post位置之後的記錄均已交換到位，故在進行下一趟排序時只要掃描到post位置即可。

改進後演算法如下。

function bubbleSort2(arr) {
  let i = arr.length - 1;
  while (i > 0) {
    let pos = 0;
    for (let j = 0; j < i; j++) {
      if (arr[j] > arr[j + 1]) {
        pos = j; // 記錄最後修改位置
        let tmp = arr[j];
        arr[j] = arr[j + 1];
        arr[j + 1] = tmp;
      }
    }
    i = pos;
  }
  return arr;
}
​
​
let arr = [3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48];
// let arr = [10, 9, 8, 7, 6, 5, 4, 3, 2, 0, 1];
console.log(bubbleSort2(arr));

傳統氣泡排序中每一趟排序操作只能找到一個最大值或最小值,我們考慮利用每趟排序中進行正向和反向兩遍冒泡的方法可以得到兩個最終值（最大者和最小者），從而使排序躺數幾乎減少了一半。

改進後的排序演算法實現為

function bubbleSort3(arr) {
  var low = 0;
  var high = arr.length - 1;
  var tmp, j;
  console.time('2.改進後的氣泡排序耗時');
  while (low < high) {

    for (j = low; j < high; j++) {
      // 這裡排序出最高的
      if (arr[j] > arr[j + 1]) { // 正向冒泡，找出最大者
        tmp = arr[j];
        arr[j] = arr[j + 1];
        arr[j + 1] = tmp;
      }
    }
    high--;

    for (j = high; j > low; j--) { // 反向冒泡 找出最小者
      if (arr[j] < arr[j - 1]) {
        tmp = arr[j];
        arr[j] = arr[j - 1];
        arr[j - 1] = tmp;
      }
    }
    low++;
  }
  console.timeEnd('2.改進後的氣泡排序耗時');
  return arr;
}


var arr = [3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48];
console.log(bubbleSort3(arr));//[2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 48, 50]

 由圖可以看出改進後的氣泡排序明顯的時間複雜度更低了，耗時更短了。

3.氣泡排序動圖演示

演算法分析

• 最佳情況：T(n) = O(n)  當輸入值的資料已經是正序時（都已經是正序了，為毛何必還排序呢....）

• 最差情況：T(n) = O(n2)  當輸入的資料是反序時(臥槽，我直接反序不就完了....)

• 平均情況：T(n) = O(n2)

2.選擇排序（Selection Sort）

表現最穩定的排序演算法之一（這個穩定性不是指演算法層面上的穩定哈），因為無論是什麼資料進去都是O(n²)的時間複雜度......所以用到它的時候，資料規模越小越好。唯一的好處可能就是不佔用額外的記憶體空間了吧。理論上講，選擇排序可能也是平時排序一般人想到的最多的排序方法了吧。

1.演算法簡介

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

2.演算法描述和實現

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

• <1>.初始狀態：無序區為R[1,...n]，有序區為空；

• <2>.第i趟排序（i=1,2,3,4,...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趟結束，陣列有序化了。

JavaScript程式碼實現

// 選擇排序
function selectionSort(arr) {
  var length = arr.length;
  var minIndex, tmp;
  console.time("選擇排序耗時");
  for (var i = 0; i < length - 1; i++) {
    minIndex = i;
    for (var j = i + 1; j < length; j++) {
      if (arr[j] < arr[minIndex]) {
        minIndex = j;
      }
    }
    tmp = arr[minIndex];
    arr[minIndex] = arr[i];
    arr[i] = tmp;
  }
  console.timeEnd("選擇排序耗時");
  return arr;
}

var arr = [3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48];
console.log(selectionSort(arr));//[2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 48, 50]

3.選擇排序動圖演示

演算法分析

• 最佳情況：T(n) = O(n)

• 最差情況：T(n) = O(n2)

• 平均情況：T(n) = O(n2)

3.插入排序(Insertion Sort)

插入排序的程式碼實現雖然沒有氣泡排序和選擇排序那麼簡單粗暴，但它的原理應該是最容易理解的了，因為只要打過撲克牌的人都應該能夠秒懂。當然，如果你說你打撲克牌摸排的時候從來不按牌的大小調整牌，那估計這輩子你對插入排序的演算法都不會產生任何興趣了...

1.演算法簡介

插入排序（Insertion-Sort）的演算法描述是一種簡單直觀的排序演算法。它的工作原理是通過構建有序序列，對於未排序資料，在已排序序列中從後向前掃描找到對應位置並插入。插入排序在實現上，通常採用in-place排序（即只需用到O(1)的額外空間的排序），因而在從後向前掃描過程中，需要反覆把一排序元素逐步向後挪威，為最新元素提供插入空間。

2.演算法的描述和實現

一般來說，插入排序都採用in-place在陣列上實現。具體的演算法描述如下：

• <1>.從第一個元素開始，該元素可以認為已經被排序。

• <2>.取出下一個元素，在已經排序的元素序列中從後向前掃描

• <3>.如果該元素（已排序）大於新元素，將該元素移到下一位置

• <4>.重複步驟3，直到找到已排序的元素小於或等於新元素的位置；

• <5>.將新元素插入到該位置後；

• <6>.重複步驟2~5

JavaScript程式碼實現：

// 這個是我的實現，感覺程式碼好長的樣子...
// 插入排序
function insertionSort(arr) {

  console.log('列印這個東西', Object.prototype.toString.call(arr), Object.prototype.toString.call(arr).slice(8, -1) === 'Array');

  var length = arr.length;
  var tmp;
  console.time('選擇排序耗時');
  for (var i = 0; i < length; i++) {
    let tmp = arr[i];
    for (var j = i; j >= 0; j--) {
      if (j === 0) {
        arr[0] = tmp;
        break;
      }

      if (tmp < arr[j - 1]) {
        arr[j] = arr[j - 1];
      } else {
        arr[j] = tmp;
        break;
      }
    }
  }
  console.timeEnd('選擇排序耗時');
  return arr;
}
// 10 7 8

var arr = [3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48];
console.log(insertionSort(arr));//[2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 48, 50]

JavaScript程式碼實現

// 插入排序
function insertionSort(arr) {
  if (Object.prototype.toString.call(arr).slice(8, -1) === 'Array') {
    console.time('插入排序耗時');
    for (var i = 1, length = arr.length; i < length; i++) {
      var key = arr[i];
      var j = i - 1;
      while (j >= 0 && arr[j] > key) {
        arr[j + 1] = arr[j];
        j--;
      }
      arr[j + 1] = key;
    }
    console.timeEnd('插入排序耗時');
    return arr;
  } else {
    return `array is not an array`;
  }
}
var arr = [3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48];
console.log(insertionSort(arr));//[2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 48, 50]

改進插入排序：查詢插入位置時使用二分查詢的方式

function binaryInsertionSort(arr) {
  if (Object.prototype.toString.call(arr).slice(8, -1) === 'Array') {
    console.time('二分插入排序耗時');
    var length = arr.length;
    for (var i = 1; i < length; i++) {

      var left = 0;
      var key = arr[i];
      var right = i - 1;

      while (left <= right) {
        var middle = parseInt((left + right) / 2);
        if (key < arr[middle]) {
          right = middle - 1;
        } else {
          left = middle + 1;
        }
      }

      for (var j = i - 1; j >= left; j--) {
        arr[j + 1] = arr[j]
      }
      arr[left] = key;
    }
    console.timeEnd('二分插入排序耗時');
    return arr;
  } else {
    throw new Error('arr is not arr');
  }
}

 改進前後對比

3.插入排序動圖演示

演算法分析

• 最佳情況：輸入陣列按升序排序。T(n) = O(n)

• 最壞情況：輸入陣列按降序排序。T(n) = O(n2)

• 平均情況：T(n) = O(n2)

4.希爾排序(Shell Sort)

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

1.演算法簡介

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

2.演算法描述和實現

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

• <1>.選擇一個增量序列t1，t2，...，tk，其中ti>tj，tk = 1

• <2>.按增量序列個數k，對序列進行k趟排序；

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

JavaScript程式碼實現

function shellSort(arr) {
  console.log('呼叫了函式方法');

  var len = arr.length;
  var tmp;
  var gap = 1;
  console.time('希爾排序耗時');
  while (gap < len / 5) { // 動態定義間隔序列
    gap = gap * 5 + 1;
    console.log('gap -------- ', gap);
  }
    
  // 在這個裡面其實是對每一組資料又進行了插入排序 真的是寫不出來不知道，想通了寫出來一次感覺就簡單了
    
  for (gap; gap > 0; gap = Math.floor(gap / 5)) {
    console.log('gap ===== >', gap);
    for (var i = 0; i < len; i++) {
      tmp = arr[i];
      for (var j = i - gap; j >= 0 && tmp < arr[j]; j -= gap) {
        arr[j + gap] = arr[j];
      }
      arr[j + gap] = tmp;
    }
  }
  console.timeEnd('希爾排序耗時');
  return arr;
}

var arr = [3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48];
console.log(shellSort(arr));//[2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 48, 50]

3.希爾排序圖示

演算法分析

• 最佳情況：T(n) = O(nlog2 n)

• 最壞情況：T(n) = O(nlog2 n)

• 平均情況：T(n) =O(nlog n)

5.歸併排序(Merge Sort)

和選擇排序一樣，歸併排序的效能不受輸入資料的影響，但表現比選擇排序好的多，因為始終都是O(n log n)的時間複雜度。代價是需要額外的記憶體空間。

1.演算法簡介

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

2.演算法描述和實現

具體演算法描述如下：

• <1>.把長度為n的輸入序列分成兩個長度為n/2的子序列；

• <2>.對這兩個子序列分別採用歸併排序。

• <3>.將兩個排序好的子序列合併成一個最終的排序序列。

JavaScript程式碼實現

// 這個思想有點難啊，看起來和之前的二叉樹的中序遍歷差不多

function mergeSort(arr) { // 採用自上而下的遞迴方法
  // console.log('mergeSort', arr);
  var length = arr.length;
  if (length < 2) {
    return arr;
  }

  var middle = Math.floor(length / 2);
  var left = arr.slice(0, middle);
  var right = arr.slice(middle);
  // console.log('mergeSort', 'left', left, 'right', right);

  return merge(mergeSort(left), mergeSort(right));
}

function merge(left, right) {
  var result = [];
  console.log('left', left, 'right', right);
  // console.time('歸併排序耗時');
  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());
  }
  // console.timeEnd('歸併排序耗時');
  return result;
}


var arr = [3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48];
console.log(mergeSort(arr));

3.歸併排序動圖演示

演算法分析：

• 最佳情況：T(n) = O(n)

• 最差情況：T(n) = O(nlogn)

• 平均情況：T(n) = O(nlogn)

6.快速排序(Quick Sort)

快速排序的名字起的是簡單粗暴，因為一聽到這個名字你就知道它存在的意義，就是快，而且效率高！它是處理大資料最快的演算法之一了。

1.演算法簡介

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

2.演算法描述和實現

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

• <1>.從數列中挑出一個元素，稱為“基準”(pivot)

• <2>.重新排序數列，所有元素比基準值小的擺放在最前面，所有元素比基準值大的擺在基準的後面（相同的可任一邊）。在這個分割槽退出之後，該基準就處於數列的中間位置。這個稱為分割槽（Partition）操作；

• <3>.遞迴的（recursive）把小於基準值元素的子數列和大於基準值元素的子數列排序。

JavaScript程式碼實現：

// 這個裡面的核心程式碼是我寫的，比它的好像差一些 它的核心原理有點沒看懂，和下面的那個動圖演示有點不一樣，他選擇的基準是右側的那個。
// 感覺不是這種排列方法

function quickSort(arr, left, right) {
  if (Object.prototype.toString.call(arr).slice(8, -1) === 'Array' && typeof length === 'number' && typeof right === 'number') {

    // console.log('進來的陣列', JSON.stringify(arr), 'left ==>', left, 'right===>', right);
    if (left < right) {
      var key = arr[left]; // 起始位置
      var setPos = left + 1; // 設定的位置
      var tmp;
      for (var i = left + 1; i <= right; i++) {
        if (arr[i] < key) {
          tmp = arr[i]; // 交換位置，並將下次小於的位置+1
          arr[i] = arr[setPos];
          arr[setPos] = tmp;
          setPos++;
        }
      }
      // 迴圈完成之後將key與 pos-1的位置交換
      arr[left] = arr[setPos - 1];
      arr[setPos - 1] = key;
      // console.log('每一次排序', '當前key值===>', key, '排序完成當前陣列===>', JSON.stringify(arr));

      quickSort(arr, left, setPos - 2);
      quickSort(arr, setPos, right);
      // console.log('arr=======>', arr);
    }
  } else {
    return 'array is not an Array or left or right is not a number!';
  }
  return arr;
}


var arr = [3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48];
// var arr = [7, 3, 2, 10, 13, 8, 5];
console.log(quickSort(arr, 0, arr.length - 1));//[2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 48, 50]

這個演算法寫法，感覺沒有我的寫法正常思維

function quickSort(array, left, right) {
    console.time('1.快速排序耗時');
    if (Object.prototype.toString.call(array).slice(8, -1) === 'Array' && typeof left === 'number' && typeof right === 'number') {
        
        if (left < right) {
            var x = array[right], i = left - 1, temp;
            for (var 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);
        }
        console.timeEnd('1.快速排序耗時');
        return array;
        
    } else {
        return 'array is not an Array or left or right is not a number!';
    }
}

3.快速排序動圖演示

這個演算法看起來簡單了許多

function quickSort(arr) {
  if (arr.length <= 1) { return arr };
  var pivoIndex = Math.floor(arr.length / 2);
  var pivot = arr.splice(pivoIndex, 1)[0]; // 將要選擇排序的那一位選舉出來 摘出來
  var left = [];
  var right = [];

  // 小的放左邊，大的放右邊
  for (var i = 0, len = arr.length; i < len; i++) {
    if (arr[i] < pivot) {
      left.push(arr[i]);
    } else {
      right.push(arr[i]);
    }
  }
  console.log('left', left, 'right', right);
  return quickSort(left).concat([pivot], quickSort(right));
}

var arr = [3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48];
// var arr = [7, 3, 2, 10, 13, 8, 5];
console.log(quickSort(arr));//[2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 48, 50]

演算法分析：

• 最佳情況：T(n) = O(nlogn)

• 最差情況：T(n) = O(n2)

• 平均情況：T(n) = O(nlogn)

7.堆排序（Heap Sort）

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

1.演算法簡介

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

2.演算法描述和實現

具體演算法描述如下

• <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，則整個排序過程完成。

JavaScript程式碼實現：

/*
  方法說明：堆排序
  @param {Array} arr 待排序陣列
*/

function heapSort(arr) {
  console.log('堆排序');


  console.log();
  if (Object.prototype.toString.call(arr).slice(8, -1) === 'Array') {

    var heapSize = arr.length;
    var temp;

    console.log('待排序陣列的長度===>', heapSize);


    console.log('建造之前的堆的樣式', JSON.stringify(arr));
    // 建造堆
    for (var i = Math.floor(heapSize / 2) - 1; i >= 0; i--) {
      heapify(arr, i, heapSize);
    }
    console.log('堆初始化完成之後的樣式', JSON.stringify(arr));

    // 現在要把最大的放到最後一個，最後一個放到第一個，把堆的大小減少一個，在慢慢的把最大的迴圈上去
    console.time('堆排序耗時');
    for (var j = heapSize - 1; j >= 1; j--) {
      temp = arr[0];
      arr[0] = arr[j];
      arr[j] = temp;
      heapify(arr, 0, --heapSize);
    }
    console.timeEnd('堆排序耗時');
    return arr;
  } else {
    return 'array is not array';
  }
}

/*
  建堆：維護堆的性質
  @param {Array} arr 陣列
  @param {Number} x 陣列下標
  @param {Number} len 堆大小
*/
function heapify(arr, x, len) {
  if (Object.prototype.toString.call(arr).slice(8, -1) === 'Array' && typeof x === 'number') {
    var l = 2 * x + 1; // 左下標
    var r = 2 * x + 2; // 右下標
    var largest = x; // 預設最大的是父節點
    var 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';
  }
}


var arr = [91, 60, 96, 13, 35, 65, 46, 65, 10, 30, 20, 31, 77, 81, 22];
console.log(heapSort(arr));//[10, 13, 20, 22, 30, 31, 35, 46, 60, 65, 65, 77, 81, 91, 96]

3.堆排序動圖演示

演算法分析

• 最佳情況：T(n) = O(nlogn)

• 最差情況：T(n) = O(nlogn)

• 平均情況：T(n) = O(nlogn)

8.計數排序(Counting Sort)

計數排序的核心在於將輸入的資料值轉化為鍵儲存在額外開闢的陣列空間中。作為一種線性時間複雜度的排序，計數排序要求輸入的資料必須是有確定範圍的整數。

1.演算法簡介

計數排序（Counting sort）是一種穩定的排序演算法。計數排序使用一個額外的陣列C，其中第i個元素是待排序陣列A中值等於i的元素的個數。然後根據陣列C來將A中的元素排到正確的位置。它只能對整數進行排序。

2.演算法描述和實現

具體演算法描述如下

• <1>.找出待排序的陣列中的最大和最小的元素；

• <2>.統計陣列中每個值為i的元素出現的次數，存入陣列C的第i項；

• <3>.對所有的計數累加（從C中的第一個元素開始，每一項和前一項相加）;

• <4>.反向填充目標陣列：將每個元素i放在新陣列的第C(i)項，每放一個元素就將C(i)減去1

JavaScript程式碼實現

function countingSort(arr) {
  console.log('計數排序');

  var len = arr.length;
  var B = [];
  var C = [];
  var min = max = arr[0];

  console.time('計數排序耗時');
  // 初始化計數排序
  for (var i = 0; i < len; i++) {
    min = min <= arr[i] ? min : arr[i];
    max = max >= arr[i] ? max : arr[i];
    C[arr[i]] = C[arr[i]] ? C[arr[i]] + 1 : 1;
  }
  console.log('初始化結束之後', JSON.stringify(C));
  var k = 0;
  for (var j = min; j < max; j++) {
    C[j + 1] = (C[j + 1] || 0) + (C[j] || 0);
  }

  console.log('計算完成之後', JSON.stringify(C));
  console.log('計算完成之後arr', JSON.stringify(arr));
  // 現在C的下標就是這個值，C的內容就是這個值的個數
  debugger;
  for (var k = len - 1; k >= 0; k--) {
    console.log('C[arr[l] - 1]===>', C[arr[k]] - 1, 'arrk===>', arr[k]);
    B[C[arr[k]] - 1] = arr[k];
    C[arr[k]]--;
  }
  console.timeEnd('計數排序耗時');
  return B;
}
var arr = [2, 2, 3, 8, 7, 1, 2, 2, 2, 7, 3, 9, 8, 2, 1, 4, 2, 4, 6, 9, 2];
console.log(countingSort(arr)); //[1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 4, 4, 6, 7, 7, 8, 8, 9, 9]

3.計數排序動圖演示

演算法分析

當輸入的元素是n個0到k之間的整數時，它的執行時間是O(n + k)。計數排序不是比較排序，排序的速度快於任何比較排序演算法。由於用來計數的陣列C的長度取決於待排序陣列中資料的範圍（等於待排序陣列的最小值的差加上1），這使得計數排序對於資料範圍很大的陣列，需要大量時間和記憶體。

• 最佳情況：T(n) = O(n + k)

• 最差情況：T(n) = O(n+k)

• 平均情況：T(n) = O(n+k)

9.桶排序（Bucket Sort）

桶排序是計數排序的升級版。它利用了函式的對映關係，高效與否的關鍵就在於這個對映函式的確定。

1.演算法簡介

桶排序(Bucket sort)的工作原理：假設輸入資料服從均勻分佈，將資料分到有限數量的桶裡，每個桶再分別排序（有可能再使用別的排序演算法或是以遞迴方式繼續使用桶排序進行排序）

2.演算法描述和實現

具體演算法描述如下：

• <1>.設定一個定量的陣列當做空桶；

• <2>.遍歷輸入資料，並且把資料一個一個放到對應的桶裡去；

• <3>.對每個不是空的桶進行排序；

• <4>.從不是空的桶裡把排好序的資料拼接起來。

/*
  方法說明：桶排序
  @param {Array} 陣列
  @param {Number} 桶的數量
*/

function bucketSort(arr, num) {
  if (arr.length <= 1) {
    return arr;
  }
  var len = arr.length;
  var buckets = [];
  var result = [];
  var min = max = arr[0];
  var regex = '/^[1-9]+[0-9]*$/';
  var space, n = 0;

  console.log('排序長度 ===>', len);

  // 定義桶的數量
  num = num || (num > 1 && regex.test(num) ? num : 10);
  console.log('桶排序耗時');
  // 尋找到最大值和最小值
  for (var i = 0; i < len; i++) {
    min = (min <= arr[i]) ? min : arr[i];
    max = (max >= arr[i]) ? max : arr[i];
  }
  console.log('最大值===> max', max, '最小值===> min', min);

  space = (max - min + 1) / num;

  for (var j = 0; j < len; j++) {
    var index = Math.floor((arr[j] - min) / space);
    console.log(`第${j}項，值==> ${arr[j]} 桶的索引為 ${index}, space ===> ${space}`);
    if (buckets[index]) { // 非空桶，插入排序
      var key = arr[j];
      var k = buckets[index].length - 1;
      while (k >= 0 && buckets[index][k] > key) {
        buckets[index][k + 1] = buckets[index][k];
        k--;
      }
      buckets[index][k + 1] = key;
    } else { // 空桶初始化
      buckets[index] = [];
      buckets[index].push(arr[j]);
    }
  }

  while (n < num) {
    result = result.concat(buckets[n]);
    n++;
  }
  console.log('桶排序完成===>', buckets);
  return result;
}



var arr = [3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48];
console.log(bucketSort(arr, 4));//[2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 48, 50]

/*方法說明：桶排序
@param  array 陣列
@param  num   桶的數量*/
function bucketSort(array, num) {
    if (array.length <= 1) {
        return array;
    }
    var len = array.length, buckets = [], result = [], min = max = array[0], regex = '/^[1-9]+[0-9]*$/', space, n = 0;
    num = num || ((num > 1 && regex.test(num)) ? num : 10);
    console.time('桶排序耗時');
    for (var i = 1; i < len; i++) {
        min = min <= array[i] ? min : array[i];
        max = max >= array[i] ? max : array[i];
    }
    space = (max - min + 1) / num;
    for (var j = 0; j < len; j++) {
        var index = Math.floor((array[j] - min) / space);
        if (buckets[index]) {   //  非空桶，插入排序
            var k = buckets[index].length - 1;
            while (k >= 0 && buckets[index][k] > array[j]) {
                buckets[index][k + 1] = buckets[index][k];
                k--;
            }
            buckets[index][k + 1] = array[j];
        } else {    //空桶，初始化
            buckets[index] = [];
            buckets[index].push(array[j]);
        }
    }
    while (n < num) {
        result = result.concat(buckets[n]);
        n++;
    }
    console.timeEnd('桶排序耗時');
    return result;
}
var arr=[3,44,38,5,47,15,36,26,27,2,46,4,19,50,48];
console.log(bucketSort(arr,4));//[2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 48, 50]

3.桶排序圖示

演算法分析

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

• 最佳情況：T(n) = O(n + k)

• 最差情況：T(n) = O(n + k)

• 平均情況：T(n) = O(n2)

10.基數排序（Radix Sort）

基數排序也是非比較的排序演算法，對每一位進行排序，從最低位開始排序，複雜度為O(kn),為陣列長度，k為陣列中的數的最大的位數；

1.演算法簡介

基數排序時按照低位先排序，然後收集；再按照高位排序，然後再收集；依次類推，直到最高位。有時候有些屬性是有優先順序順序的，先按低優先順序排序，再按高優先順序排序。最後的次序就是高優先順序高的在前，高優先順序相同的低優先順序高的在前。基數排序基於分別排序，分別收集，所以是穩定的。

2.演算法描述和實現

具體演算法描述如下：

• <1>.取得陣列中的最大數，並取得位數。

• <2>.arr為原始陣列，從最低位開始取每個位組成radix陣列；

• <3>.對radix進行計數排序（利用計數排序適用於小範圍數的特點）

JavaScript程式碼實現

/*
  基數排序適用於：
    (1)資料範圍比較小,建議小於1000
    (2)每個數值都要大於等於0
  
  @param {Array} arr 待排序陣列
  @param {Number} 最大位數
*/
function radixSort(arr, maxDigit) {
  var mod = 10;
  var dev = 1;
  var counter = [];

  console.time('基數排序耗時');
  for (var i = 0; i < maxDigit; i++ , mod *= 10, dev *= 10) {
    for (var j = 0, len = arr.length; j < len; j++) {
      var bucket = parseInt((arr[j] % mod) / dev);
      console.log('基數===>', bucket);
      if (counter[bucket] == null) {
        counter[bucket] = [];
      }
      counter[bucket].push(arr[j]);
    }

    console.log('第一次排序完成===>', counter);
    // 將排序好的再次重整排列
    var pos = 0;
    for (var j = 0; j < counter.length; j++) {
      console.log('counter[j] ===>', 'j===>', j, counter[j]);
      if (counter[j] != null) {
        while ((value = counter[j].shift()) != null) {
          arr[pos++] = value;
        }
      }
    }
    console.log('第一次排序完成 arr ===>', arr);
  }

  console.timeEnd('基數排序耗時');
  return arr;
}

var arr = [3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48];
console.log(radixSort(arr, 2)); //[2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 48, 50]

3.基數排序動圖演示

演算法分析

• 最佳情況：T(n) = O(n * k)

• 最差情況：T(n) = O(n * k)

• 平均情況：T(n) = O(n * k)

基數排序有兩種方法

• MSD從高位開始進行排序

• LSD從低位開始進行排序

基數排序 vs 計數排序 vs 桶排序

這三種方法都利用了桶的概念，但對桶的使用方法上有明顯差異：

1.基數排序：根據鍵值的每位數字來分配桶

2.計數排序：每個桶只儲存單一鍵值

3.桶排序：每個桶儲存一定範圍的數值

後記

感覺他說的這句話挺好的，也是我的一些感受吧

十大排序演算法的總結到這裡就算告一段落了。博主總結完之後只有一個感覺，排序演算法博大精深，前輩們用了數年甚至一輩子的心血研究出來的演算法更值得我們推敲。站在十大演算法的門前心裡還是誠惶誠恐的，身為一個小學生，博主的總結難免會有所疏漏，歡迎各位批評指正。

此文參考了 https://github.com/zhangyachang/Sorts 寫的，他寫的很好。

如果你看了我的文章學到了一些東西，那我會非常高興的。

&n