手撕前端面試之經典排序算法 (動圖+視頻)

時間  2021-02-27
標籤 javascript html 前端 java git github 面試 算法 api 數組 欄目 快樂工作 简体版
原文   原文鏈接

觀感度：🌟🌟🌟🌟🌟javascript

口味：小炒黃牛肉html

烹飪時間：10min前端

本文已收錄在前端食堂同名倉庫 Github github.com/Geekhyt，歡迎光臨食堂，若是以爲酒菜還算可口，賞個 Star 對食堂老闆來講是莫大的鼓勵。

排序算法是面試中的高頻考察點，咱們須要熟練掌握。本文整理了最經典、最經常使用的排序算法而且搭配了動圖和視頻，但願可以幫助你更加輕鬆的拿下它們。java

首先，根據排序算法的特性能夠分紅以下兩類：git

  • 比較類排序
  • 非比較類排序

顧名思義，比較類排序是經過元素間的比較進行排序的，非比較類則不涉及元素之間的比較操做。github

比較類排序的時間複雜度不能突破 O(nlogn)，也被稱爲非線性排序。面試

非比較類排序的時間複雜度能夠突破 O(nlogn)，可以以線性的時間運行，也被稱爲線性排序。算法

若是你還不瞭解時間複雜度的話，能夠移步個人這篇專欄JavaScript算法時間、空間複雜度分析。api

01 冒泡排序 Bubble Sort

冒泡排序可視化視頻數組

冒泡排序，簡單粗暴，一句話解釋:

冒泡排序在每次冒泡操做時會比較相鄰的兩個元素，看是否知足大小關係要求，不知足就將它倆互換。一直迭代到再也不須要交換，也就是排序完成。

const bubbleSort = function(arr) {
  const len = arr.length
  if (len < 2) return arr
  for (let i = 0; i < len; i++) {
      for (let j = 0; j < len - i - 1; j++) {
          if (arr[j] > arr[j + 1]) {
              const temp = arr[j]
              arr[j] = arr[j + 1]
              arr[j + 1] = temp
          }
      }
  }
  return arr
}
  • 時間複雜度: O(n^2)
  • 空間複雜度: O(1)
  • 穩定

注意：這裏的穩定是指，冒泡排序是穩定的排序算法。

什麼是穩定的排序算法呢？

排序算法的穩定性

僅僅用執行效率和內存消耗來判斷排序算法的優劣是不夠的，針對排序算法，還有一個重要的度量指標，穩定性。

意思是說，若是待排序的序列中存在值相等的元素，通過排序以後，相等元素之間原有的前後順序不變。

舉個🌰：

好比咱們有一組數據：1，9，2，5，8，9。按照大小排序以後就是 1，2，5，8，9，9。

這組數據中有兩個 9，通過某種排序算法排序後，若是兩個 9 的先後順序沒有改變，咱們就把這種排序算法稱爲 穩定的排序算法。
不然，就是不穩定的排序算法。

冒泡排序優化

上面的代碼還能夠進行優化，當某次冒泡操做已經沒有數據交換時，說明已經達到徹底有序，不須要再繼續執行後續的冒泡操做了。

const bubbleSort = function(arr) {
  const len = arr.length
  let flag = false
  if (len < 2) return arr
  for (let i = 0; i < len; i++) {
      flag = false // 提早退出冒泡循環的標誌
      for (let j = 0; j < len - i - 1; j++) {
          if (arr[j] > arr[j + 1]) {
              const temp = arr[j]
              arr[j] = arr[j + 1]
              arr[j + 1] = temp
              flag = true // 表示有數據交換
          }
      }
      if (!flag) break // 沒有數據交換，提早退出
  }
  return arr
}

02 插入排序 Insertion Sort

image

插入排序顧名思義，對於未排序的數據，在已排序的序列中從後往前掃描，找到相應的位置進行插入，保持已排序序列中元素一直有序。

從 i 等於 1 開始遍歷，拿到當前元素 curr，與前面的元素進行比較。

若是前面的元素大於當前元素，就把前面的元素和當前元素進行交換，不斷循環直到未排序序列中元素爲空，排序完成。

const insertSort = function(arr) {
    const len = arr.length
    let curr, prev
    for (let i = 1; i < len; i++) {
        curr = arr[i]
        prev = i - 1
        while (prev >= 0 && arr[prev] > curr) {
            arr[prev + 1] = arr[prev]
            prev--
        }
        arr[prev + 1] = curr
    }
    return arr
}
  • 時間複雜度: O(n^2)
  • 空間複雜度: O(1)
  • 穩定

03 選擇排序 Selection Sort

選擇排序可視化視頻

選擇排序和插入排序有些相似，也分已排序序列和未排序序列。

可是選擇排序是將最小的元素存放在數組起始位置，再從剩下的未排序的序列中尋找最小的元素，而後將其放到已排序的序列後面。以此類推，直到排序完成。

const selectSort = function(arr) {
    const len = arr.length
    let temp, minIndex
    for (let i = 0; i < len - 1; i++) {
        minIndex = i
        for (let 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
}
  • 時間複雜度: O(n^2)
  • 空間複雜度: O(1)
  • 不穩定

04 歸併排序 Merge Sort

image

分治法典型應用，分治算法思想很大程度上是基於遞歸的，也比較適合用遞歸來實現。

處理過程是由下到上的，先處理子問題，而後再合併。

若是感受本身對遞歸掌握的還不是很透徹的同窗，能夠移步個人這篇專欄你真的懂遞歸嗎？。

顧名思義，分而治之。通常分爲如下三個過程：

  1. 分解：將原問題分解成一系列子問題。
  2. 解決：遞歸求解各個子問題，若子問題足夠小，則直接求解。
  3. 合併：將子問題的結果合併成原問題。

歸併排序就是將待排序數組不斷二分爲規模更小的子問題處理，再將處理好的子問題合併起來，這樣整個數組就都有序了。

const mergeSort = function(arr) {
    const merge = (right, left) => {
    const result = []
    let i = 0, j = 0
    while (i < left.length && j < right.length) {
      if (left[i] < right[j]) {
        result.push(left[i++])
      } else {
        result.push(right[j++])
      }
    }
    while (i < left.length) {
      result.push(left[i++])
    }
    while (j < right.length) {
      result.push(right[j++])
    }
    return result
    }
    const sort = (arr) => {
        if (arr.length === 1) { return arr }
        const mid = Math.floor(arr.length / 2)
        const left = arr.slice(0, mid)
        const right = arr.slice(mid, arr.length)
        return merge(mergeSort(left), mergeSort(right))
    }
    return sort(arr)
}
  • 時間複雜度: O(nlogn)
  • 空間複雜度: O(n)
  • 穩定

05 快速排序 Quick Sort

快速排序可視化視頻

快速排序也是分治法的應用，處理過程是由上到下的，先分區，而後再處理子問題。

快速排序經過遍歷數組，將待排序元素分隔成獨立的兩部分，一部分記錄的元素均比另外一部分的元素小，則能夠分別對這兩部分記錄的元素繼續進行排序，直到排序完成。

這就須要從數組中挑選出一個元素做爲 基準(pivot)，而後從新排序數列，將元素比基準值小的放到基準前面，比基準值大的放到基準後面。

而後將小於基準值的子數組(left)和大於基準值的子數組(right)遞歸地調用 quick 方法，直到排序完成。

const quickSort = function(arr) {
    const quick = function(arr) {
        if (arr.length <= 1) return arr
        const len = arr.length
        const index = Math.floor(len >> 1)
        const pivot = arr.splice(index, 1)[0]
        const left = []
        const right = []
        for (let i = 0; i < len; i++) {
            if (arr[i] > pivot) {
                right.push(arr[i])
            } else if (arr[i] <= pivot) {
                left.push(arr[i])
            }
        }
        return quick(left).concat([pivot], quick(right))
    }
    const result = quick(arr)
    return result
}
  • 時間複雜度: O(nlogn)
  • 空間複雜度: O(nlogn)
  • 不穩定

06 堆排序 Heap Sort

image

堆排序相比其餘幾種排序代碼會有些複雜，不過不要緊，咱們先來看一些前置知識，能夠幫助咱們更好的理解堆排序。

堆排序顧名思義就是要利用堆這種數據結構進行排序。堆是一種特殊的樹，知足如下兩點就是堆：

  1. 堆是一個徹底二叉樹
  2. 堆中每個節點的值都必須大於等於(或小於等於)其子樹中的每一個節點的值

每一個節點的值都大於等於子樹中每一個節點值的堆，叫作大頂堆，每一個節點的值都小於等於子樹中每一個節點值的堆，叫作小頂堆。

也就是說，大頂堆中，根節點是堆中最大的元素。小頂堆中，根節點是堆中最小的元素。

若是你對樹這種數據結構還不是很瞭解，能夠移步個人這篇專欄「樹」業有專攻

堆若是用一個數組表示的話，給定一個節點的下標 i (i從1開始)，那麼它的父節點必定爲 A[i / 2]，左子節點爲 A[2i]，右子節點爲 A[2i + 1]。

堆排序包含兩個過程，建堆和排序。首先構建一個大頂堆，也就是將最大值存儲在根節點(i = 1)，每次取大頂堆的根節點與堆的最後一個節點進行交換，此時最大值放入了有效序列的最後一位，而且有效序列減 1，有效堆依然保持徹底二叉樹的結構，而後進行堆化成爲新的大頂堆。重複此操做，直到有效堆的長度爲 0，排序完成。 
const heapSort = function(arr) {
    buildHeap(arr, arr.length - 1)
    let heapSize = arr.length - 1 // 初始化堆的有效序列長度
    for (let i = arr.length - 1; i > 1; i--) {
        swap(arr, 1, i) // 交換堆頂元素與最後一個有效子元素
        heapSize-- // 有效序列長度減 1
        heapify(arr, heapSize, 1) // 堆化有效序列
    }
    return arr
}

// 構建大頂堆
const buildHeap = function(items, heapSize) {
    // 從後往前並非從序列的最後一個元素開始，而是從最後一個非葉子節點開始，這是由於，葉子節點沒有子節點，不須要自上而下式堆化。
    // 最後一個子節點的父節點爲 n/2 ，因此從 n/2 位置節點開始堆化
    for (let i = Math.floor(heapSize / 2); i >= 1; i--) {
        heapify(items, heapSize, i)
    }
}
// 堆化
const heapify = function(arr, heapSize, i) {
    while (true) {
        let maxIndex = i
        if (2 * i <= heapSize && arr[i] < arr[i * 2]) {
            maxIndex = i * 2
        }
        if (2 * i + 1 <= heapSize && arr[maxIndex] < arr[i * 2 + 1]) {
            maxIndex = i * 2 + 1
        }
        if (maxIndex === i) break
        swap(arr, i, maxIndex)
        i = maxIndex
    }
}

// 交換工具函數
const swap = function(arr, i, j) {
    let temp = arr[i]
    arr[i] = arr[j]
    arr[j] = temp
}
  • 時間複雜度: O(nlogn)
  • 空間複雜度: O(1)
  • 不穩定

爲了方便你理解和記憶，我將這 6 種排序算法的複雜度和穩定性彙總成表格以下：

本文講解了十大經典排序算法中的 6 種排序算法，這 6 種排序算法是平時開發中比較常見的，你們務必要熟練掌握。

剩下的希爾排序、計數排序、桶排序、基數排序，若是你感興趣的話能夠戳下面連接進行學習。

站在巨人的肩膀上

2021 組團刷題計劃

年初立了一個 flag，上面這個倉庫在 2021 年寫滿 100 道前端面試高頻題解，目前進度已經完成了 1 / 3。

若是你也準備刷或者正在刷 LeetCode，不妨加入前端食堂，一塊兒並肩做戰，刷個痛快。

❤️愛心三連擊

1.若是你以爲食堂酒菜還合胃口，就點個贊支持下吧，你的贊是我最大的動力。

2.關注公衆號前端食堂，吃好每一頓飯！

3.點贊、評論、轉發 === 催更！

image

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程