十大基本算法介紹

原文：https://www.cnblogs.com/onepixel/articles/7674659.html

一、算法概述：

1.算法分類：

十種常見算法可以分為兩大類：

• 比較類排序：通過比較來決定元素間的相對次序，由於其時間復雜度不能超過Q(nlogn)，因此也稱為非線性時間比較類排序。
• 非比較類排序：不通過比較來決定元素間的相對次序，它可以突破基於比較排序的時間下限， 以線性時間運行， 因此也稱為線性時間非比較類排序。

2.算法復雜度：

算法復雜度

排序方法	時間復雜度(平均)	時間復雜度(最壞)	時間復雜度(最好)	空間復雜度	穩定性
插入排序	O(n2)	O(n2)	O(n)	O(1)	穩定
希爾排序	O(n1.3)	O(n2)	O(n)	O(1)	不穩定
選擇排序	O(n2)	O(n2)	O(n2)	O(1)	不穩定
堆排序	O(nlog2n)	O(nlog2n)	O(nlog2n)	O(1)	不穩定
冒泡排序	O(n2)	O(n2)	O(n)	O(1)	穩定
快速排列	O(nlog2n)	O(n2)	O(nlog2n)	O(nlog2n)	不穩定
歸並排序	O(nlog2n)	O(nlog2n)	O(nlog2n)	O(n)	穩定
計數排序	O(n+k)	O(n+k)	O(n+k)	O(n+k)	穩定
桶排序	O(n+k)	O(n2)	O(n)	O(n+k)	穩定
計數排序	O(n*k)	O(n*k)	O(n*k)	O(n+k)	穩定

3.相關概念：

• 穩定：如果a 原本在 b 前面，而a=b， 排序之后a 任然在b前面。

• 不穩定：如果 a 原本在 b 前面，而 a = b, 排序之后 a 可能會出現在 b 的后面。

• 時間復雜度：對排列數據的總的操作次數。反映當 n 變化時，操作次數呈現什么規律。

• 空間復雜度：是指算法在計算機內執行時所需存儲空間的度量，它也是數據規模 n 的函數。

 4.算法的選擇：

• 若n較小( 如n≤50)， 可采用直接插入或直接選擇排序；

• 若文件初始狀態基本有序(指正序)，則應選用直接插入、冒泡或隨機的快速排序為宜；

• 若n較大，則應采用時間復雜度為O(n log n) 的排序方法：快速排序、堆排序或歸並排序；

• 若n較小，考慮穩定性，可以使用：基數排序、計數排序或者桶排序。

    其中 插入算法和 歸並算法 對重復率比較高的排序比較友好；冒泡算法不適合大量數據。

二、具體定義：

1.冒泡排序：

    * 概念：冒泡排序是一種簡單的排序算法。它重復地走訪過要排序的數列，一次比較兩個元素，如果它們的順序錯誤就把它們交換過來。走訪數列的工作是重復地進行直到沒有再需要交換，也就是說該數列已經排序完成。這個算法的名字由來是因為越小的元素會經由交換慢慢“浮”到數列的頂端。

     *算法描述:

• 比較相鄰的元素。如果第一個比第二個大，就交換它們兩個；

• 對每一對相鄰元素作同樣的工作，從開始第一對到結尾的最后一對，這樣在最后的元素應該會是最大的數；

• 針對所有的元素重復以上的步驟，除了最后一個；

• 重復步驟1~3，直到排序完成。

     *動畫演示：

 *算法實例：

 function bubbleSort(arr) {
        var len = arr.length;
        for (var i = 0; i < len - 1; i++) {
            for (var j = 0; j < len - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) { // 相鄰元素兩兩對比
                    var temp = arr[j + 1]; // 元素交換
                    arr[j + 1] = arr[j];
                    arr[j] = temp;
                }
            }
        }
        return arr;
    }
    var arr = [6, 5, 4, 3, 2, 1];
    console.log(arr); // [6, 5, 4, 3, 2, 1]
    bubbleSort(arr);
    console.log(arr); // [1, 2, 3, 4, 5, 6]

 

2.選擇排序：

 *概念： 選擇排序(Selection-sort)是一種簡單直觀的排序算法。它的工作原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再從剩余未排序元素中繼續尋找最小（大）元素，然后放到已排序序列的末尾。以此類推，直到所有元素均排序完畢。

    表現最穩定的排序算法之一，因為無論什么數據進去都是O(n2)的時間復雜度，所以用到它的時候，數據規模越小越好。唯一的好處可能就是不占用額外的內存空間了吧。理論上講，選擇排序可能也是平時排序一般人想到的最多的排序方法了吧。

 

 *算法描述: 

   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+1..n)分別變為記錄個數增加1個的新有序區和記錄個數減少1個的新無序區；

• n-1趟結束，數組有序化了。

 

 *動畫演示：

*算法實例：

function selectionSort(arr) {
        if (arr == null || arr.length < 2) {
            return arr;
        }
        for (var i = 0; i < (arr.length - 1); i++) {
            let minIndex = i;
                for (let j = i + 1; j < arr.length; j++) {
                    minIndex = arr[j] < arr[minIndex] ? j : minIndex;
                }
            let temp = arr[i];
            arr[i] = arr[minIndex];
            arr[minIndex] = temp;
          }
        return arr;
     }
    var arr = [1, 3, 2, 8, 9, 1, 5];
    console.log(arr); // [1, 3, 2, 8, 9, 1, 5]
    selectionSort(arr);
    console.log(arr); // [1, 1, 2, 3, 5, 8, 9]

 

3.插入排序：

*概念：插入排序（Insertion-Sort）的算法描述是一種簡單直觀的排序算法。它的工作原理是通過構建有序序列，對於未排序數據，在已排序序列中從后向前掃描，找到相應位置並插入。

    插入排序在實現上，通常采用in-place排序（即只需用到O(1)的額外空間的排序），因而在從后向前掃描過程中，需要反復把已排序元素逐步向后挪位，為最新元素提供插入空間。

 

*算法描述: 

  一般來說，插入排序都采用in-place在數組上實現。具體算法描述如下：

• 從第一個元素開始，該元素可以認為已經被排序；

• 取出下一個元素，在已經排序的元素序列中從后向前掃描；

• 如果該元素（已排序）大於新元素，將該元素移到下一位置；

• 重復步驟3，直到找到已排序的元素小於或者等於新元素的位置；

• 將新元素插入到該位置后；

• 重復步驟2~5。

 

*動畫演示：

*算法實例：

function insertionSort(arr) {
        if (arr == null || arr.length < 2) {
            return arr;
        }
        for (let i = 1; i < arr.length; i++) {
            for (let j = i - 1; j >= 0 && arr[j] > arr[j + 1]; j--) {
                let temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
        return arr;
    }
    var arr = [3, 4, 2, 1, 6, 7, 8, 4];
    console.log(arr); // [3, 4, 2, 1, 6, 7, 8, 4]
    insertionSort(arr);
    console.log(arr); // [1, 2, 3, 4, 4, 6, 7, 8]

 

4.希爾排序：

*概念：1959年Shell發明，第一個突破O(n2)的排序算法，是簡單插入排序的改進版。它與插入排序的不同之處在於，它會優先比較距離較遠的元素。希爾排序又叫縮小增量排序。

    希爾排序的核心在於間隔序列的設定。既可以提前設定好間隔序列，也可以動態的定義間隔序列。動態定義間隔序列的算法是《算法（第4版）》的合著者Robert Sedgewick提出的。　

 

*算法描述:

    先將整個待排序的記錄序列分割成為若干子序列分別進行直接插入排序，具體算法描述：

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

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

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

 

*動畫演示：

*算法實例：

function shellSort(arr) {
        var len = arr.length;
        for (var gap = Math.floor(len / 2); gap > 0; gap = Math.floor(gap /2)) {
            for (var i = gap; i < len; i++) {
                for (var j = i - gap; j >= 0 && arr[j] > arr[gap + j]; j -= gap) {
                    var temp = arr[j];
                    arr[j] = arr[gap + j];
                    arr[gap + j] = temp;
                }
            }
        }
    }
    var arr = [49, 38, 65, 97, 76, 13, 27, 49, 55, 04];
    console.log(arr); // [49, 38, 65, 97, 76, 13, 27, 49, 55, 4]
    shellSort(arr);
    console.log(arr); // [4, 13, 27, 38, 49, 49, 55, 65, 76, 97]

 

5.歸並算法：

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

    歸並排序是一種穩定的排序方法。和選擇排序一樣，歸並排序的性能不受輸入數據的影響，但表現比選擇排序好的多，因為始終都是O(nlogn）的時間復雜度。代價是需要額外的內存空間。

 

*算法描述:

• 把長度為n的輸入序列分成兩個長度為n/2的子序列；

• 對這兩個子序列分別采用歸並排序；

• 將兩個排序好的子序列合並成一個最終的排序序列。

 

*動畫演示：

*算法實例：

function mergeSort(arr) {
        if (arr.length == 1) {
            return arr;
        }
        var mid = Math.floor(arr.length / 2);
        var leftArr = arr.slice(0, mid);
        var rightArr = arr.slice(mid);
        return merge(mergeSort(leftArr), mergeSort(rightArr));
    }
 
    function merge(leftArr, rightArr) {
        var result = [];
        while (leftArr.length && rightArr.length) {
            if (leftArr[0] < rightArr[0]) {
                result.push(leftArr.shift());
            } else {
                result.push(rightArr.shift());
            }
        }
        return result.concat(leftArr).concat(rightArr);
    }
 
    var arr = [6, 4, 2, 1, 12, 4, 6, 5, 5, 0];
    console.log(arr); // [6, 4, 2, 1, 12, 4, 6, 5, 5, 0]
    console.log(mergeSort(arr)); // [0, 1, 2, 4, 4, 5, 5, 6, 6, 12]

 

6.快速排序：

*概念：快速排序的基本思想：通過一趟排序將待排記錄分隔成獨立的兩部分，其中一部分記錄的關鍵字均比另一部分的關鍵字小，則可分別對這兩部分記錄繼續進行排序，以達到整個序列有序。

 

*算法描述:

快速排序使用分治法來把一個串（list）分為兩個子串（sub-lists）。具體算法描述如下：

• 從數列中挑出一個元素，稱為 “基准”（pivot）；

• 重新排序數列，所有元素比基准值小的擺放在基准前面，所有元素比基准值大的擺在基准的后面（相同的數可以到任一邊）。在這個分區退出之后，該基准就處於數列的中間位置。這個稱為分區（partition）操作；

• 遞歸地（recursive）把小於基准值元素的子數列和大於基准值元素的子數列排序。

 

*動畫演示：

*算法實例：

const quickSort = (array) => {
        const sort = (arr, left = 0, right = arr.length - 1) => {
            if (left >= right) { //如果左邊的索引大於等於右邊的索引說明整理完畢
                return
            }
            let i = left
            let j = right
            const baseVal = arr[j] // 取無序數組最后一個數為基准值
            while (i < j) { //把所有比基准值小的數放在左邊大的數放在右邊
                while (i < j && arr[i] <= baseVal) { //找到一個比基准值大的數交換
                    i++
                }
            arr[j] = arr[i] // 將較大的值放在右邊如果沒有比基准值大的數就是將自己賦值給自己（i 等於 j）
                while (j > i && arr[j] >= baseVal) { //找到一個比基准值小的數交換
                    j--
                }
            arr[i] = arr[j] // 將較小的值放在左邊如果沒有找到比基准值小的數就是將自己賦值給自己（i 等於 j）
          }
        arr[j] = baseVal // 將基准值放至中央位置完成一次循環（這時候 j 等於 i ）
        sort(arr, left, j - 1) // 將左邊的無序數組重復上面的操作
        sort(arr, j + 1, right) // 將右邊的無序數組重復上面的操作
        }
        const newArr = array.concat() // 為了保證這個函數是純函數拷貝一次數組
        sort(newArr)
        return newArr
    }
    var arr = [6,5,4,5,3,4,1];
    console.log(arr); // [6, 5, 4, 5, 3, 4, 1]
    console.log(quickSort(arr)); // [1, 3, 4, 4, 5, 5, 6]

 

7.堆排序：

*概念：堆排序（Heapsort）是指利用堆這種數據結構所設計的一種排序算法。堆積是一個近似完全二叉樹的結構，並同時滿足堆積的性質：即子結點的鍵值或索引總是小於（或者大於）它的父節點。

 

*算法描述:

• 將初始待排序關鍵字序列(R1,R2….Rn)構建成大頂堆，此堆為初始的無序區；

• 將堆頂元素R[1]與最后一個元素R[n]交換，此時得到新的無序區(R1,R2,……Rn-1)和新的有序區(Rn),且滿足R[1,2…n-1]<=R[n]；

• 由於交換后新的堆頂R[1]可能違反堆的性質，因此需要對當前無序區(R1,R2,……Rn-1)調整為新堆，然后再次將R[1]與無序區最后一個元素交換，得到新的無序區(R1,R2….Rn-2)和新的有序區(Rn-1,Rn)。不斷重復此過程直到有序區的元素個數為n-1，則整個排序過程完成。

 

*動畫演示：

*算法實例：

function heapSort(arr) {
        var len; // 因為聲明的多個函數都需要數據長度，所以把len設置成為全局變量
        buildMaxHeap(arr);
 
        for (var i = arr.length - 1; i > 0; i--) {
            swap(arr, 0, i);
            len--;
            heapify(arr, 0);
        }
 
 
        function buildMaxHeap(arr) { // 建立大頂堆
        len = arr.length;
        for (var i = Math.floor(len / 2); i >= 0; i--) {
            heapify(arr, i);
            }
        }
 
        function heapify(arr, i) { // 堆調整
        var left = 2 * i + 1,
        right = 2 * i + 2,
        largest = i;
 
        if (left < len && arr[left] > arr[largest]) {
            largest = left;
            }
 
        if (right < len && arr[right] > arr[largest]) {
            largest = right;
            }
 
        if (largest != i) {
            swap(arr, i, largest);
            heapify(arr, largest);
            }
        }
 
        function swap(arr, i, j) {
            var temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
         }
    return arr;
    }
    var arr = [2,6,5,3,8,4,10,23];
    console.log(arr); // [2, 6, 5, 3, 8, 4, 10, 23]
    heapSort(arr);
    console.log(arr); // [2, 3, 4, 5, 6, 8, 10, 23]

 

8.計數排序：

*概念：計數排序不是基於比較的排序算法，其核心在於將輸入的數據值轉化為鍵存儲在額外開辟的數組空間中。 作為一種線性時間復雜度的排序，計數排序要求輸入的數據必須是有確定范圍的整數。

    計數排序是一個穩定的排序算法。當輸入的元素是 n 個 0到 k 之間的整數時，時間復雜度是O(n+k)，空間復雜度也是O(n+k)，其排序速度快於任何比較排序算法。當k不是很大並且序列比較集中時，計數排序是一個很有效的排序算法。

 

*算法描述:

• 找出待排序的數組中最大和最小的元素；

• 統計數組中每個值為i的元素出現的次數，存入數組C的第i項；

• 對所有的計數累加（從C中的第一個元素開始，每一項和前一項相加）；

• 反向填充目標數組：將每個元素i放在新數組的第C(i)項，每放一個元素就將C(i)減去1。

 

*動畫演示：

*算法實例：

function countingSort(arr, maxValue) {
        var bucket = new Array(maxValue + 1),
        sortedIndex = 0,
        arrLen = arr.length,
        bucketLen = maxValue + 1;
 
        for (var i = 0; i < arrLen; i++) {
            if (!bucket[arr[i]]) {
                bucket[arr[i]] = 0;
            }
            bucket[arr[i]]++;
        }
 
        for (var j = 0; j < bucketLen; j++) {
            while (bucket[j] > 0) {
                arr[sortedIndex++] = j;
                bucket[j]--;
            }
        }
 
        return arr;
    }
    var arr = [4, 3, 3, 2, 3, 4, 5, 6, 3, 5, 6, 4, 6, 5, 2, 1, 2];
    console.log(arr);
    countingSort(arr,6);
    console.log(arr);

 

9.桶排序：

*概念：桶排序是計數排序的升級版。它利用了函數的映射關系，高效與否的關鍵就在於這個映射函數的確定。

        桶排序 (Bucket sort)的工作的原理：假設輸入數據服從均勻分布，將數據分到有限數量的桶里，每個桶再分別排序（有可能再使用別的排序算法或是以遞歸方式繼續使用桶排序進行排）。

        桶排序最好情況下使用線性時間O(n)，桶排序的時間復雜度，取決與對各個桶之間數據進行排序的時間復雜度，因為其它部分的時間復雜度都為O(n)。很顯然，桶划分的越小，各個桶之間的數據越少，排序所用的時間也會越少。但相應的空間消耗就會增大。

 

 

*算法描述: 

• 設置一個定量的數組當作空桶；

• 遍歷輸入數據，並且把數據一個一個放到對應的桶里去；

• 對每個不是空的桶進行排序；

• 從不是空的桶里把排好序的數據拼接起來。

 

*動畫演示：

*算法實例：

function bucketSort(arr, bucketSize) {
        if (arr.length === 0) {
        return arr;
        }
 
        var i;
        var minValue = arr[0];
        var maxValue = arr[0];
        for (i = 1; i < arr.length; i++) {
            if (arr[i] < minValue) {
                minValue = arr[i]; // 輸入數據的最小值
            } else if (arr[i] > maxValue) {
                maxValue = arr[i]; // 輸入數據的最大值
            }
        }
 
        // 桶的初始化
        var DEFAULT_BUCKET_SIZE = 5; // 設置桶的默認數量為5
        // 桶的個數
        bucketSize = parseInt(bucketSize) > 0 ? parseInt(bucketSize) : DEFAULT_BUCKET_SIZE;
        // 分成 bucketSize 個桶，桶所占用的范圍
        var bucketCount = Math.floor((maxValue - minValue) / bucketSize) + 1;
        // 初始化桶
        var buckets = new Array(bucketCount);
        for (i = 0; i < buckets.length; i++) {
            buckets[i] = [];
        }
 
        // 利用映射函數將數據分配到各個桶中
        for (i = 0; i < arr.length; i++) {
            buckets[Math.floor((arr[i] - minValue) / bucketSize)].push(arr[i]);
        }
 
        arr.length = 0;
        for (i = 0; i < buckets.length; i++) {
            insertionSort(buckets[i]); // 對每個桶進行排序，這里使用了插入排序
            for (var j = 0; j < buckets[i].length; j++) {
                arr.push(buckets[i][j]);
            }
        }
 
       return arr;
 
        function insertionSort(arr) {
            if (arr == null || arr.length < 2) {
                return arr;
            }
            for (let i = 1; i < arr.length; i++) {
                for (let j = i - 1; j >= 0 && arr[j] > arr[j + 1]; j--) {
                    let temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
            return arr;
            }
    }
    var arr = [8, 39, 400, 500, 3, 4, 20, 44, 440];
    console.log(arr); // [8, 39, 400, 500, 3, 4, 20, 44, 440]
    bucketSort(arr, 10);
    console.log(arr); // [3, 4, 8, 20, 39, 44, 400, 440, 500]

 

10.基數排序：

*概念：基數排序是按照低位先排序，然后收集；再按照高位排序，然后再收集；依次類推，直到最高位。有時候有些屬性是有優先級順序的，先按低優先級排序，再按高優先級排序。最后的次序就是高優先級高的在前，高優先級相同的低優先級高的在前。

    基數排序基於分別排序，分別收集，所以是穩定的。但基數排序的性能比桶排序要略差，每一次關鍵字的桶分配都需要O(n)的時間復雜度，而且分配之后得到新的關鍵字序列又需要O(n)的時間復雜度。假如待排數據可以分為d個關鍵字，則基數排序的時間復雜度將是O(d*2n) ，當然d要遠遠小於n，因此基本上還是線性級別的。

    基數排序的空間復雜度為O(n+k)，其中k為桶的數量。一般來說n>>k，因此額外空間需要大概n個左右。

 

 

*算法描述:

• 取得數組中的最大數，並取得位數；

• arr為原始數組，從最低位開始取每個位組成radix數組；

• 對radix進行計數排序（利用計數排序適用於小范圍數的特點）；

 

*動畫演示：

*算法實例：

function radixSort(arr, maxDigit) {
        var counter = [];
        var mod = 10;
        var dev = 1;
        for (var i = 0; i < maxDigit; i++, dev *= 10, mod *= 10) {
            // 把待排序的數組 arr 中的每一位整數，插入對應的容器
            for (var j = 0; j < arr.length; j++) {
                // 從個位開始，得到數組中每個數的每一位並保存在 bucket 變量中
                // bucket 變量的值可能為 0 1 2 3 4 5 6 7 8 9
                // 與之對應的 counter[bucket] 容器為 0 1 2 3 4 5 6 7 8 9
                var bucket = parseInt((arr[j] % mod) / dev);
                // 如果目前 bucket 變量的值對應的 counter[bucket] 容器還不存在（未初始化），則創建（初始化）一個新的空容器
                if (counter[bucket] == null) {
                    counter[bucket] = [];
                }
                // 現在把這個 bucket 變量的值插入對應的 counter[bucket] 容器的尾部
                counter[bucket].push(arr[j]);
            }
            // 把 counter[bucket] 容器里的數依次取出
            var pos = 0;
            for (var j = 0; j < counter.length; j++) {
                var value = null;
                if (counter[j] != null) {
                    while ((value = counter[j].shift()) != null) {
                        arr[pos++] = value;
                    }
                }
             }
        }
        return arr;
    }
    var arr = [4, 5, 3, 1, 7, 4, 3, 2, 0, 4, 3];
    console.log(arr); // [4, 5, 3, 1, 7, 4, 3, 2, 0, 4, 3]
    radixSort(arr, 3)
    console.log(arr); // [0, 1, 2, 3, 3, 3, 4, 4, 4, 5, 7]