JS數據結構與算法_排序和搜索算法

上一篇：JS數據結構與算法_樹

寫在前面

這是《學習JavaScript數據結構與算法》的最後一篇博客，也是在面試中經常會被問到的一部份內容：排序和搜索。在這篇博客以前，我往往看到排序頭就是大的，內心想着相似「冒泡排序，兩層遍歷啪啪啪「就完事了，而後再也無意去深刻研究排序相關的問題了。若是你也有相似的經歷，但願下面的內容對你有必定幫助

1、準備

在進入正題以前，先準備幾個基礎的函數

（1）交換數組兩個元素

function swap(arr, sourceIndex, targetIndex) {
  let temp = arr[sourceIndex];
  arr[sourceIndex] = arr[targetIndex];
  arr[targetIndex] = temp;
}

（2）快速生成0~N的數組 可點擊查看更多生成方法

function createArr(length) {
  return Array.from({length}, (_, i) => i);
}

（3）洗牌函數

洗牌函數可快速打亂數組，常見的用法如切換音樂播放順序

function shuffle(arr) {
  for (let i = 0; i < arr.length; i += 1) {
    const rand = Math.floor(Math.random() * (i + 1));
    if (rand !== i) {
      swap(arr, i, rand);
    }
  }
  return arr;
}

2、排序

常見排序算法能夠分爲兩大類：

• 比較類排序：經過比較來決定元素間的相對次序，因爲其時間複雜度不能突破O(nlogn)，所以也稱爲非線性時間比較類排序
• 非比較類排序：不經過比較來決定元素間的相對次序，它能夠突破基於比較排序的時間下界，以線性時間運行，所以也稱爲線性時間非比較類排序

在本篇博客中，僅對比較類排序的幾種排序方式進行學習介紹

2.1 冒泡排序

冒泡排序是全部排序算法中最簡單的，一般也是咱們學習排序的入門方法。可是，從運行時間的角度來看，冒泡排序是最差的一種排序方式。

核心：比較任何兩個相鄰的項，若是第一個比第二個大，則交換它們。元素項向上移動至正確的順序，就好像氣泡升至表面同樣，冒泡排序於是得名

動圖：

注意：第一層遍歷找出剩餘元素的最大值，至指定位置【依次冒泡出最大值】

代碼：

function bubbleSort(arr) {
  const len = arr.length;
  for (let i = 0; i < len; i += 1) {
    for (let j = 0; j < len - 1 - i; j += 1) {
      if (arr[j] > arr[j + 1]) { // 比較相鄰元素
        swap(arr, j, j + 1);
      }
    }
  }
  return arr;
}

2.2 選擇排序

選擇排序是一種原址比較排序算法。

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

動圖：

注意：第一層遍歷找出剩餘元素最小值的索引，而後交換當前位置和最小值索引值【依次找到最小值】

代碼：

function selectionSort(arr) {
  const len = arr.length;
  let minIndex;
  for (let i = 0; i < len - 1; i += 1) {
    minIndex = i;
    for (let j = i + 1; j < len; j += 1) {
      if (arr[minIndex] > arr[j]) {
        minIndex = j; // 尋找最小值對應的索引
      }
    }
    if (minIndex === i) continue;
    swap(arr, minIndex, i);
  }
  return arr;
}

2.3 插入排序

插入排序的比較順序不一樣於冒泡排序和選擇排序，插入排序的比較順序是當前項向前比較。

核心：經過構建有序序列，對於未排序數據，在已排序序列中從後向前掃描，找到相應位置並插入

動圖：

注意：從第二項開始，依次向前比較，保證當前項之前的序列是順序排列

代碼：

function insertionSort(arr) {
  const len = arr.length;
  let current, pointer;
  for (let i = 1; i < len; i += 1) {
    current = arr[i];
    pointer = i;
    while(pointer >= 0 && current < arr[pointer - 1]) { // 每次向前比較
      arr[pointer] = arr[pointer - 1]; // 前一項大於指針項，則向前移動一項
      pointer -= 1;
    }
    arr[pointer] = current; // 指針項還原成當前項
  }
  return arr;
}

2.4 歸併排序

歸併排序和快速排序相較於上面三種排序算法在實際中更具備可行性（在第四小節咱們會經過實踐複雜度來比較這幾種排序算法）

JavaScript的 Array類定義了一個 sort函數( Array.prototype.sort)用以排序 JavaScript數組。 ECMAScript沒有定義用哪一個排序算法，因此瀏覽器廠商能夠自行去實現算法。例如， Mozilla Firefox使用 歸併排序做爲 Array.prototype.sort的實現，而 Chrome使用了一個 快速排序的變體

歸併排序是一種分治算法。其思想是將原始數組切分紅較小的數組，直到每一個小數組只有一 個位置，接着將小數組歸併成較大的數組，直到最後只有一個排序完畢的大數組。所以須要用到遞歸

核心：歸併排序，拆分紅左右兩塊數組，分別排序後合併

動圖：

注意：遞歸中最小的左右數組比較爲單個元素的數組，所以在較上層多個元素對比時，左右兩個數組必定是順序的

代碼：

function mergeSort(arr) {
  const len = arr.length;

  if (len < 2) return arr; // 遞歸的終止條件
  const middle = Math.floor(len / 2); // 拆分左右數組
  const left = arr.slice(0, middle);
  const right = arr.slice(middle);
  
  return merge(mergeSort(left), mergeSort(right));
}

function merge(left, right) { // 將左右兩側比較後進行合併
  const ret = [];

  while (left.length && right.length) {
    if (left[0] > right[0]) {
      ret.push(right.shift());
    } else {
      ret.push(left.shift());
    }
  }

  while (left.length) {
    ret.push(left.shift());
  }
  while (right.length) {
    ret.push(right.shift());
  }

  return ret;
}

2.5 快速排序

快速排序也許是最經常使用的排序算法了。它的複雜度爲O(nlogn)，且它的性能一般比其餘的復 雜度爲O(nlogn)的排序算法要好。和歸併排序同樣，快速排序也使用分治的方法，將原始數組分爲較小的數組

核心：分治算法，以參考值爲界限，將比它小的和大的值拆開

動圖：

注意：每一次遍歷篩選出比基準點小的值

代碼：

function quickSort(arr, left = 0, right = arr.length - 1) {
  // left和right默認爲數組首尾
  if (left < right) {
    let partitionIndex = partition(arr, left, right);
    quickSort(arr, left, partitionIndex - 1);
    quickSort(arr, partitionIndex + 1, right);
  }
  return arr;
}

function partition(arr, left, right) {
  let pivot = left;
  let index = left + 1; // 知足比較條件的依次放在分割點後

  for (let i = index; i <= right; i += 1) {
    if (arr[i] < arr[pivot]) {
      swap(arr, i, index);
      index += 1;
    }
  }
  swap(arr, index - 1, pivot); // 交換順序時，以最後一位替換分隔項
  return index - 1;
}

3、搜索算法

3.1 順序搜索

順序或線性搜索是最基本的搜索算法。它的機制是，將每個數據結構中的元素和咱們要找的元素作比較。順序搜索是最低效的一種搜索算法。

function findItem(item, arr) {
  for (let i = 0; i < arr.length; i += 1) {
    if (item === arr[i]) {
      return i;
    }
  }
  return -1;
}

3.2 二分搜索

二分搜索要求被搜索的數據結構已排序。如下是該算法遵循的步驟：

1. 選擇數組的中間值
2. 若是選中值是待搜索值，那麼算法執行完畢
3. 若是待搜索值比選中值要小，則返回步驟1在選中值左邊的子數組中尋找
4. 若是待搜索值比選中值要大，則返回步驟1在選中值右邊的子數組中尋找

function binarySearch(item, arr) {
  arr = quickSort(arr); // 排序

  let low = 0;
  let high = arr.length - 1;
  let mid;

  while (low <= high) {
    min = Math.floor((low + high) / 2);
    if (arr[mid] < item) {
      low = mid + 1;
    } else if (arr[mid] > item) {
      high = mid - 1;
    } else {
      return mid;
    }
  }
  return -1;
}

4、算法複雜度

4.1 理解大O表示法

大O表示法用於描述算法的性能和複雜程度。分析算法時，時常遇到一下幾類函數

（1）O(1)

function increment(num){
    return ++num;
}

執行時間和參數無關。所以說，上述函數的複雜度是O(1)(常數)

（2）O(n)

以順序搜索函數爲例，查找元素須要遍歷整個數組，直到找到該元素中止。函數執行的總開銷取決於數組元素的個數(數組大小)，並且也和搜索的值有關。可是函數複雜度取決於最壞的狀況：若是數組大小是10，開銷就是10；若是數組大小是1000，開銷就是1000。這種函數的時間複雜度是O(n)，n是(輸入)數組的大小

（3）O(n2)

以冒泡排序爲例，在未優化的狀況下，每次排序均需進行n*n次執行。時間複雜度爲O(n2)

時間複雜度 O(n)的代碼只有一層循環，而 O(n2)的代碼有雙層嵌套循環。如 果算法有三層遍歷數組的嵌套循環，它的時間複雜度極可能就是 O(n3)

4.2 時間複雜度比較

（1）經常使用數據結構時間複雜度

（2）排序算法時間複雜度

上一篇：JS數據結構與算法_樹
參考：十大經典排序算法（動圖演示）