JavaScript實現經典排序算法

時間 2019-12-12

原文原文鏈接

先看一下各個算法的時間複雜度和空間複雜度
說明：
時間複雜度：指的是一個算法執行所耗費的時間
空間複雜度指：運行完一個程序所需內存的大小
穩定指：若是a=b,a在b的前面，排序後a仍然在b的前面
不穩定指：若是a=b，a在b的前面，排序後可能會交換位置javascript

下面主要經過文字和動圖介紹冒泡排序、選擇排序、快速排序和插入排序這些經典的排序算法，並用js代碼實現html

1. 冒泡排序（Bubble Sort）

冒泡排序可謂是最經典的排序算法了，它是基於比較的排序算法，其優勢是實現簡單，排序數量較小時性能較好。
它重複地走訪過要排序的數列，一次比較兩個元素，若是它們的順序錯誤就把它們交換過來。走訪數列的工做是重複地進行直到沒有再須要交換，也就是說該數列已經排序完成。這個算法的名字由來是由於越小的元素會經由交換慢慢「浮」到數列的頂端。java

1. 1 算法原理

相鄰的數據進行兩兩比較，小數放在前面，大數放在後面，若是前面的數據比後面的數據大，就交換這兩個數的位置。也能夠實現大數放在前面，小數放在後面，若是前面的數據比後面的小，就交換兩個的位置。要實現上述規則須要用到兩層for循環。git

1. 2 算法描述

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

1. 3 動圖演示

1. 4 js代碼實現

function bubbleSort(arr) {
  var len = arr.length;
  for (var i = 0; i < len; i++) {
    for (var j = 0; j < len - 1 - i; j++) {
      if (arr[j] > arr[j + 1]) { // 相鄰元素兩兩對比
      // 元素交換
      /** 1.使用中間變量 **/ 
        var temp = arr[j + 1]; 
        arr[j + 1] = arr[j]
        arr[j] = temp
        /** 2.適用純數字的數組排序 **/
        arr[j] = arr[j] +  arr[j + 1]
        arr[j + 1] =  arr[j] - arr[j + 1]
        arr[j] -= arr[j + 1]
        /** 3.使用es6解構賦值 **/
        [arr[j]， arr[j + 1]] = [arr[j + 1], arr[j]]
      }
    }
  }
  return arr;
}
複製代碼

冒泡排序算法優化es6

function bubbleSort(arr) {
  var len = arr.length;
  for (var i = 0; i < len; i++) {
    var exchange=false; // 交換標誌 
    for (var j = 0; j < len - 1 - i; j++) {
      if (arr[j] > arr[j + 1]) { // 相鄰元素兩兩對比
        [arr[j], arr[j + 1]] = [arr[j + 1], arr[j]] // 元素交換
        exchange=true; //
      }
    }
    if(!exchange){ // 若本趟排序未發生交換，提早終止算法
        break;
    }
  }
  return arr;
}

複製代碼

2. 選擇排序（Selection Sort）

表現最穩定的排序算法之一，由於不管什麼數據進去都是O(n²)的時間複雜度。。。因此用到它的時候，數據規模越小越好。惟一的好處可能就是不佔用額外的內存空間了吧。github

2. 1 算法原理

先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，而後，再從剩餘未排序元素中繼續尋找最小（大）元素，而後放到已排序序列的末尾。以此類推，直到全部元素均排序完畢。面試

2. 2 算法描述

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

初始狀態：無序區爲R[1..n]，有序區爲空；
第i趟排序(i=1,2,3…n-1)開始時，當前有序區和無序區分別爲R[1..i-1]和R(i..n）。該趟排序從當前無序區中-選出關鍵字最小的記錄R[k]，將它與無序區的第1個記錄R交換，使R[1..i]和R[i+..n)分別變爲記錄個數增長1個的新有序區和記錄個數減小1個的新無序區；
n-1趟結束，數組有序化了。

2. 3 動圖演示

2. 4 js代碼實現

function selectionSort(arr) {
    var len = arr.length;
    var minIndex, temp;
    for (var i = 0; i < len - 1; i++) {
        minIndex = i;
        for (var j = i + 1; j < len; j++) {
            if (arr[j] < arr[minIndex]) {     //尋找最小的數
                minIndex = j;                 //將最小數的索引保存
            }
        }
        temp = arr[i];
        arr[i] = arr[minIndex];
        arr[minIndex] = temp;
    }
    return arr;
}

複製代碼

3. 插入排序（Insertion Sort）

插入排序（Insertion-Sort）的算法描述是一種簡單直觀的排序算法。數組

3. 1 算法原理

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

3. 2 算法描述

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

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

3. 3 動圖演示

3. 4 js代碼實現

function insertSort(arr) {
  // 從1位置開始遍歷arr中每元素，同時聲明空變量temp
  for (let i = 1; i < arr.length; i++) {
    if (arr[i] < arr[i - 1]) { // 若是當前元素<前一個元素
      let temp = arr[i] // 將當前元素值臨時保存在temp中
      let p = i - 1 // 定義變量 p = i- 1
      // 循環 條件：
      // 1. p>=0且temp小於p位置的元素
      while (p >= 0 && temp < arr[p]) {
        // 循環體： 將P位置的值賦值給p的後一個元素
        arr[p + 1] = arr[p]
        p-- // p向前移動一個
      }
      arr[p + 1] = temp // 將temp的值賦值給p+1位置的元素
    }
  }
}
複製代碼

4. 快速排序（Selection Sort）

快速排序是由東尼·霍爾所發展的一種排序算法。在平均情況下，排序 n 個項目要 Ο(nlogn) 次比較。在最壞情況下則須要 Ο(n2) 次比較，但這種情況並不常見。事實上，快速排序一般明顯比其餘 Ο(nlogn) 算法更快，由於它的內部循環（inner loop）能夠在大部分的架構上頗有效率地被實現出來。

4. 1 算法原理

快速排序又是一種分而治之思想在排序算法上的典型應用。本質上來看，快速排序應該算是在冒泡排序基礎上的遞歸分治法。

4. 2 算法描述

選基準：在數據結構中選擇一個元素做爲基準(pivot
劃分區：參照基準元素值的大小，劃分無序區，全部小於基準元素的數據放入一個區間，全部大於基準元素的數據放入另外一區間，分區操做結束後，基準元素所處的位置就是最終排序後它應該所處的位置
遞歸：對初次劃分出來的兩個無序區間，遞歸調用第 1步和第 2步的算法，直到全部無序區間都只剩下一個元素爲止。

4. 3 動圖演示

4. 4 js代碼實現

function quickSort(arr){
    //若是arr.length<=1,則直接返回arr
    if(arr.length<=1){return arr}
    // arr的元素個數/2，再下去整，將值保存在pivotIndex中
    var pivotIndex=Math.floor(arr.length/2);
    // 將arr中pivotIndex位置的元素，保存在變量pivot中
    var pivot=arr[pivotIndex];
    //聲明空數組left和right
    var left=[];
    var right=[];
    for(var i=0;i<arr.length;i++){  // 遍歷arr中每一個元素
        if(i !== pivotIndex){ // 若是i !== pivotIndex
            if(arr[i]<=pivot){ // 若是當前元素值<pivot
                left.push(arr[i]); // 就將當前值壓入left
            }else{
                right.push(arr[i]); // 就將當前值壓入right
            }
        }
    }
    //遞歸
    return quickSort(left).concat(pivot, quickSort(right)); // 連接多個數組到 left 從小到大
}
複製代碼