JavaScript實現的7種排序演算法

guojikun發表於2021-07-02
JavaScript排序演算法

所謂排序演算法，即通過特定的演算法因式將一組或多組資料按照既定模式進行重新排序。這種新序列遵循著一定的規則，體現出一定的規律，因此，經處理後的資料便於篩選和計算，大大提高了計算效率。對於排序，我們首先要求其具有一定的穩定性，即當兩個相同的元素同時出現於某個序列之中，則經過一定的排序演算法之後，兩者在排序前後的相對位置不發生變化。換言之，即便是兩個完全相同的元素，它們在排序過程中也是各有區別的，不允許混淆不清。

氣泡排序

氣泡排序是入門級的演算法，但也有一些有趣的玩法。通常來說，氣泡排序有三種寫法：

一邊比較一邊向後兩兩交換，將最大值 / 最小值冒泡到最後一位；
經過優化的寫法：使用一個變數記錄當前輪次的比較是否發生過交換，如果沒有發生交換表示已經有序，不再繼續排序；

基礎演算法

空間複雜度為 \(O(1)\)，時間複雜度為 \(O(n^2)\)

const sort = (arr) => {
    for (let i = 0, len = arr.length; i < len-1; i++){
        for (let j = 0; j < len-1-i; j++) {
            if (arr[j] > arr[j+1]) {
                [arr[j], arr[j+1]] = [arr[j+1], arr[j]];
            }
        }
    }
    return arr
}

最外層的 for 迴圈每經過一輪，剩餘數字中的最大值就會被移動到當前輪次的最後一位，中途也會有一些相鄰的數字經過交換變得有序。總共比較次數是 (n-1)+(n-2)+(n-3)+…+1(n−1)+(n−2)+(n−3)+…+1。

第二種寫法是在基礎演算法的基礎上改良而來的：

const sort = (arr) => {
    for (let i = 0, len = arr.length; i < len - 1; i++) {
        let isSwap = false
        for (let j = 0; j < len - 1 - i; j++) {
            if (arr[j] > arr[j + 1]) {
                [arr[j], arr[j + 1]] = [arr[j + 1], arr[j]];
                isSwap = true
            }
        }
        if (!isSwap) {
            break;
        }
    }
    return arr;
};

空間複雜度為\(O(1)\);時間複雜度為 \(O(n^2)\)-最好為O(n);

最外層的 for 迴圈每經過一輪，剩餘數字中的最大值仍然是被移動到當前輪次的最後一位。這種寫法相對於第一種寫法的優點是：如果一輪比較中沒有發生過交換，則立即停止排序，因為此時剩餘數字一定已經有序了。

選擇排序

選擇排序的思想是：雙重迴圈遍歷陣列，每經過一輪比較，找到最小元素的下標，將其交換至首位。

基礎演算法

const sort = (arr) => {
    for (let i = 0, len = arr.length; i < len - 1; i++) {
        let minIndex = i
        for (let j = i+1; j < len; j++) {
            if (arr[i] > arr[j]) {
                minIndex = j
            }
        }
        [arr[i], arr[minIndex]] = [arr[minIndex], arr[i]];
    }
    return arr;
};

二元選擇排序-優化

選擇排序演算法也是可以優化的，既然每輪遍歷時找出了最小值，何不把最大值也順便找出來呢？這就是二元選擇排序的思想。

使用二元選擇排序，每輪選擇時記錄最小值和最大值，可以把陣列需要遍歷的範圍縮小一倍。

const sort = (arr) => {
    for (let i = 0, len = arr.length; i < len / 2; i++) {
        let minIndex = i;
        let maxIndex = i;
        for (let j = i + 1; j < len-i; j++) {
            if (arr[minIndex] > arr[j]) {
                minIndex = j;
            }
            if (arr[maxIndex] < arr[j]) {
                maxIndex = j;
            }
        }
        if (minIndex === maxIndex) break;
        [arr[i], arr[minIndex]] = [arr[minIndex], arr[i]];
        if (maxIndex === i) {
            maxIndex = minIndex;
        }
        const lastIndex = len - i - 1;
        [arr[maxIndex], arr[lastIndex]] = [arr[lastIndex], arr[maxIndex]];
    }
    return arr; 
};

插入排序

插入排序的思想非常簡單，生活中有一個很常見的場景：在打撲克牌時，我們一邊抓牌一邊給撲克牌排序，每次摸一張牌，就將它插入手上已有的牌中合適的位置，逐漸完成整個排序。

插入排序有兩種寫法：

  • 交換法：在新數字插入過程中，不斷與前面的數字交換，直到找到自己合適的位置。
  • 移動法：在新數字插入過程中，與前面的數字不斷比較，前面的數字不斷向後挪出位置，當新數字找到自己的位置後，插入一次即可。

交換法插入排序

const sort = (arr) => {
    for (let i = 1, len = arr.length; i < len; i++) {
        let j = i;
        while (j >= 1 && arr[j] < arr[j - 1]) {
            [arr[j], arr[j - 1]] = [arr[j - 1], arr[j]];
            j--
        }
    }
    return arr;
};

當數字少於兩個時，不存在排序問題，當然也不需要插入，所以我們直接從第二個數字開始往前插入。

移動法

我們發現，在交換法插入排序中，每次都要交換數字。但實際上，新插入的這個數字並不一定適合與它交換的數字所在的位置。也就是說，它剛換到新的位置上不久，下一次比較後，如果又需要交換，它馬上又會被換到前一個數字的位置。

由此，我們可以想到一種優化方案：讓新插入的數字先進行比較，前面比它大的數字不斷向後移動，直到找到適合這個新數字的位置後再插入。

這種方案我們需要把新插入的數字暫存起來，程式碼如下：

const sort = (arr) => {
    for (let i = 1, len = arr.length; i < len; i++) {
        let j = i-1;
        let cur = arr[i];
        while (j >= 0 && cur < arr[j]) {
            arr[j+1] = arr[j]
            j--;
        }
        arr[j+1] = cur
    }
    return arr;
};

希爾排序

1959 年 77 月，美國辛辛那提大學的數學系博士 Donald Shell 在 《ACM 通訊》上發表了希爾排序演算法，成為首批將時間複雜度降到\(O(n^2)\)以下的演算法之一。雖然原始的希爾排序最壞時間複雜度仍然是\(O(n^2)\)，但經過優化的希爾排序可以達到\(O(n^{1.3})\)甚至 \(O(n^{7/6})\)。

希爾排序本質上是對插入排序的一種優化，它利用了插入排序的簡單，又克服了插入排序每次只交換相鄰兩個元素的缺點。它的基本思想是：

  • 將待排序陣列按照一定的間隔分為多個子陣列，每組分別進行插入排序。這裡按照間隔分組指的不是取連續的一段陣列，而是每跳躍一定間隔取一個值組成一組
  • 逐漸縮小間隔進行下一輪排序
  • 最後一輪時，取間隔為 11，也就相當於直接使用插入排序。但這時經過前面的「巨集觀調控」，陣列已經基本有序了，所以此時的插入排序只需進行少量交換便可完成
    舉個例子，對陣列[8, 3, 34, 6, 4, 1, 44, 45, 43, 2, 23]進行希爾排序的過程如下：

第一遍（5 間隔排序）：按照間隔 5 分割子陣列，共分成五組，分別是[8, 1, 23],[3, 44],[34, 45],[6, 43],[4, 2]。對它們進行插入排序，排序後它們分別變成：[1, 8, 23],[3, 44],[34, 45],[6, 43],[2, 4]，此時整個陣列變成 [1, 3, 34, 6, 2, 8, 44, 45, 43, 4, 23]

第二遍（2 間隔排序）：按照間隔 2 分割子陣列，共分成兩組，分別是[1, 34, 2, 44, 43, 23],[3, 6, 8, 45, 4]。對他們進行插入排序，排序後它們分別變成：[1, 2, 23, 34, 43, 44],[3, 4, 6, 8, 45]，此時整個陣列變成[1, 3, 2, 4, 23, 6, 34, 8, 43, 45, 44]。這裡有一個非常重要的性質：當我們完成 2 間隔排序後，這個陣列仍然是保持 5 間隔有序的。也就是說，更小間隔的排序沒有把上一步的結果變壞。

第三遍（11 間隔排序，等於直接插入排序）：按照間隔 1 分割子陣列，分成一組，也就是整個陣列。對其進行插入排序，經過前兩遍排序，陣列已經基本有序了，所以這一步只需經過少量交換即可完成排序。排序後陣列變成[1, 2, 3, 4, 6, 8, 23, 34, 43, 44, 45]，整個排序完成。

const sort = arr => {
    const len = arr.length;
    if (len < 2) {
        return arr;
    }
    let gap = Math.floor(len / 2);
    while (gap > 0) {
        for (let i = gap; i < len; i++) {
            let j = i;
            let cur = arr[i];
            while (j >= 0 && cur < arr[j - gap]) {
                arr[j] = arr[j - gap];
                j -= gap;
            }
            arr[j] = cur;
        }
        gap = Math.floor(gap / 2);
    }
    return arr;
}

堆排序

堆排序過程如下：

  1. 用數列構建出一個大頂堆，取出堆頂的數字(放到待排序陣列的最後)；
  2. 調整剩餘的數字，構建出新的大頂堆，再次取出堆頂的數字；
  3. 迴圈往復，完成整個排序。
function sort(arr) {
    for (let i = Math.floor(arr.length / 2) - 1; i >= 0; i--) {
        adjustHeap(arr, i, arr.length)
    }
    for (let j = arr.length - 1; j > 0; j--) {
        [arr[0], arr[j]] = [arr[j], arr[0]]
        adjustHeap(arr, 0, j)
    }
}

function adjustHeap(arr, i, length) {
    let tmp = arr[i]
    for (let k = i * 2 + 1; k < length; k = k * 2 + 1) {
        if (k + 1 < length && arr[k] < arr[k + 1]) {
            k++;
        }
        if (arr[k] > tmp) {
            arr[i] = arr[k];
            i = k;
        } else {
            break;
        }
        arr[i] = tmp;
    }
}

快速排序

快速排序演算法由 C. A. R. Hoare 在 1960 年提出。它的時間複雜度也是 \(O(nlogn)\)，但它在時間複雜度為 \(O(nlogn)\) 級的幾種排序演算法中，大多數情況下效率更高，所以快速排序的應用非常廣泛。再加上快速排序所採用的分治思想非常實用，使得快速排序深受面試官的青睞，所以掌握快速排序的思想尤為重要。

快速排序演算法的基本思想是：

  • 從陣列中取出一個數，稱之為基數（pivot）

  • 遍歷陣列，將比基數大的數字放到它的右邊，比基數小的數字放到它的左邊。遍歷完成後，陣列被分成了左右兩個區域

  • 將左右兩個區域視為兩個陣列，重複前兩個步驟，直到排序完成

  • 事實上，快速排序的每一次遍歷，都將基數擺到了最終位置上。第一輪遍歷排好 1 個基數，第二輪遍歷排好 2 個基數（每個區域一個基數，但如果某個區域為空，則此輪只能排好一個基數），第三輪遍歷排好 4 個基數（同理，最差的情況下，只能排好一個基數），以此類推。總遍歷次數為 \(logn\)～\(n\) 次，每輪遍歷的時間複雜度為 \(O(n)\)，所以很容易分析出快速排序的時間複雜度為 \(O(nlogn)\) ～\(O(n^2)\)，平均時間複雜度為 \(O(nlogn)\)。

const partition = (arr, start, end) => {
    let pivot = arr[start]; // 取第一個數為基數
    let left = start + 1; // 從第二個數開始分割槽
    let right = end; // 右邊界
    // left、right 相遇時退出迴圈
    while (left < right) {
        // 找到第一個大於基數的位置
        while (left < right && arr[left] <= pivot) left++;
        // 交換這兩個數，使得左邊分割槽都小於或等於基數，右邊分割槽大於或等於基數
        if (left != right) {
            [arr[left], arr[right]] = [arr[right], arr[left]];
            right--;
        }
    }
    // 如果 left 和 right 相等，單獨比較 arr[right] 和 pivot
    if (left == right && arr[right] > pivot) right--;
    // 將基數和中間數交換
    if (right != start) [arr[left], pivot] = [pivot, arr[left]];
    // 返回中間值的下標
    return right;
}

const quickSort = (arr, start, end) => {
    if (start >= end) return;
    const middle = partition(arr, start, end)
    quickSort(arr, start, middle - 1);
    quickSort(arr, middle + 1, end);
}

const sort = arr => {
    quickSort(arr, 0, arr.length -1);
}

歸併排序

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

演算法描述

  • 把長度為n的輸入序列分成兩個長度為n/2的子序列；
  • 對這兩個子序列分別採用歸併排序；
  • 將兩個排序好的子序列合併成一個最終的排序序列。
const merge = (left, right) => {
    let result = [];
    while (left.length > 0 && right.length > 0) {
        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());
    return result;
}

const sort = (arr) => {
    let len = arr.length;
    if (len < 2) {
        return arr;
    }
    const middle = Math.floor(len / 2),
        left = arr.slice(0, middle),
        right = arr.slice(middle);
    return merge(sort(left), sort(right));
};

相關文章