js 經常使用排序

1. 冒泡排序

原理：從第一個元素開始，把當前元素和下一個索引元素進行比較。若是當前元素大，那麼就交換位置，重複操做直到比較到最後一個元素

    function bubbleSort(arr) {
      if (Array.isArray(arr)) {
        for (var i = arr.length - 1; i > 0; i--) {
          for (var j = 0; j < i; j++) {
            if (arr[j] > arr[j + 1]) {
              [arr[j], arr[j + 1]] = [arr[j + 1], arr[j]];
            }
          }
        }
        return arr;
      }
    }

2.插入排序

原理：第一個元素默認是已排序元素，取出下一個元素和當前元素比較，若是當前元素大就交換位置。那麼此時第一個元素就是當前的最小數，因此下次取出操做從第三個元素開始，向前對比，重複以前的操做。

    function insertSort(arr) {
      if (Array.isArray(arr)) {
        for (var i = 1; i < arr.length; i++) {
          var preIndex = i - 1;
          var current = arr[i]
          while (preIndex >= 0 && arr[preIndex] > c) {
            arr[preIndex + 1] = arr[preIndex];
            preIndex--;
          }
          arr[preIndex + 1] = current;
        }
        return arr;
      }
    }

3.選擇排序

原理：遍歷數組，設置最小值的索引爲 0，若是取出的值比當前最小值小，就替換最小值索引，遍歷完成後，將第一個元素和最小值索引上的值交換。如上操做後，第一個元素就是數組中的最小值，下次遍歷就能夠從索引 1 開始重複上述操做。

    function selectSort(arr) {
      if (Array.isArray(arr)) {
        for (var i = 0; i < arr.length - 1; i++) {
          var minIdex = i;
          for (var j = i + 1; j < arr.length; j++) {
            minIdex = arr[j] < arr[minIdex] ? j : minIdex;
          }
          [arr[i], arr[minIdex]] = [arr[minIdex], arr[i]];
        }
        return arr;
      }
    }

4.快速排序

原理：在數據集之中，找一個基準點，創建兩個數組，分別存儲左邊和右邊的數組，利用遞歸進行下次比較。

    function quickSort(arr) {
      if (!Array.isArray(arr)) return;
      if (arr.length <= 1) return arr;
      var left = [], right = [];
      var num = Math.floor(arr.length / 2);
      var numValue = arr.splice(num, 1)[0];
      for (var i = 0; i < arr.length; i++) {
        if (arr[i] > numValue) {
          right.push(arr[i]);
        } else {
          left.push(arr[i]);
        }
      }
      return [...quickSort(left), numValue, ...quickSort(right)]
    }

5. 希爾排序

原理：

選擇一個增量序列 t1，t2，……，tk，其中 ti > tj, tk = 1；

按增量序列個數 k，對序列進行 k 趟排序；

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

 

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

 

6.歸併排序

原理：

（1） 把長度爲n的輸入序列分紅兩個長度爲n/2的子序列；

（2）對這兩個子序列分別採用歸併排序；

（3） 將兩個排序好的子序列合併成一個最終的排序序列。

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

    function merge(left, right) {
      var result = [];
      while (left.length && right.length) {
        // 不斷比較left和right數組的第一項，小的取出存入res
        left[0] < right[0] ? result.push(left.shift()) : result.push(right.shift());
      }
      return result.concat(left, right);
    }

 

未完待續...