金九銀十跳槽季——七種排序算法

關注公衆號「 執鳶者」，獲取大量教學視頻及 私人總結麪筋（公衆號原創文章）並進入 專業交流羣

被前端面試中算法虐慘的小林準備大幹一場，好好準備一下面試中的高頻算法題，因爲前端算法相比於後端手撕的算法較容易，因此小林準備從最基礎的七種排序算法開始。前方高能，請抓住方向盤……

1、冒泡排序

冒泡排序的思路：遍歷數組，而後將最大數沉到最底部；<br/> 時間複雜度：O(N^2)；<br/> 空間複雜度：O(1)

function BubbleSort(arr) {
    if(arr == null || arr.length <= 0){
        return [];
    }
    var len = arr.length;
    for(var end = len - 1; end > 0; end--){
        for(var i = 0; i < end; i++) {
            if(arr[i] > arr[i + 1]){
                swap(arr, i, i + 1);
            }
        }
    }
    return arr;
}
function swap(arr, i, j){
    // var temp = arr[i];
    // arr[i] = arr[j];
    // arr[j] = temp;
    //交換也能夠用異或運算符
    arr[i] = arr[i] ^ arr[j];
    arr[j] = arr[i] ^ arr[j];
    arr[i] = arr[i] ^ arr[j];
}

2、選擇排序

選擇排序的實現思路：遍歷數組，把最小數放在頭部；<br/> 時間複雜度：O(N^2)；<br/> 空間複雜度：O(1)

function SelectionSort(arr) {
    if(arr == null || arr.length < 0) {
        return [];
    }
    for(var i = 0; i < arr.length - 1; i++) {
        var minIndex = i;
        for(var j = i + 1; j < arr.length; j++) {
            minIndex = arr[j] < arr[minIndex] ? j : minIndex;
        }
        swap(arr, i, minIndex);
    }
    return arr;
}

function swap(arr, i, j) {
    arr[i] = arr[i] ^ arr[j];
    arr[j] = arr[i] ^ arr[j];
    arr[i] = arr[i] ^ arr[j];
}

3、插入排序

插入排序實現思路：將一個新的數，和前面的比較，只要當前數小於前一個則和前一個交換位置，不然終止；<br/> 時間複雜度：O(N^2)；<br/> 空間複雜度：O(1)

function insertSort(arr) {
    if(arr == null  || arr.length <= 0){
        return [];
    }
    var len = arr.length;
    for(var i = 1; i < len; i++) {
        for(var j = i - 1; j >= 0 && arr[j] > arr[j + 1]; j--) {
            swap(arr, j, j + 1);
        }
    }
    return arr;
}

function swap(arr, i, j){
    var temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}

4、歸併排序

歸併排序的思路：<br/>1.先左側部分排好序<br/>2.再右側部分排好序<br/>3.再準備一個輔助數組，用外排的方式，小的開始填，直到有個動到末尾，將另外一個數組剩餘部分拷貝到末尾<br/>4.再將輔助數組拷貝回原數組<br/> 時間複雜度:O(N * logN)<br/> 空間複雜度:O(N)

// 遞歸實現

function mergeSort(arr){
    if(arr == null  || arr.length <= 0){
        return [];
    }
    sortProcess(arr, 0, arr.length - 1);
    return arr;
}

function sortProcess(arr, L, R){
    //遞歸的終止條件，就是左右邊界索引同樣
    if(L == R){
        return;
    }
    var middle = L + ((R - L) >> 1);//找出中間值
    sortProcess(arr, L, middle);//對左側部分進行遞歸
    sortProcess(arr, middle + 1, R);//對右側部分進行遞歸
    merge(arr, L, middle, R);//而後利用外排方式進行結合
}

function merge(arr, L, middle, R){
    var help = [];
    var l = L;
    var r = middle + 1;
    var index = 0;
    //利用外排方式進行
    while(l <= middle && r <= R){
        help[index++] = arr[l] < arr[r] ? arr[l++] : arr[r++];
    }
    while(l <= middle){
        help.push(arr[l++]);
    }
    while(r <= R){
        help.push(arr[r++]);
    }

    for(var i = 0; i < help.length; i++) {
        arr[L + i] = help[i];
    }
    //arr.splice(L, help.length, ...help);//這個利用了ES6的語法
}

// 循環實現

function mergeSort(arr){
    if(arr ==null || arr.length <= 0){
        return [];
    }
    var len = arr.length;
    //i每次乘2，是由於每次合併之後小組元素就變成兩倍個了
    for(var i = 1; i < len; i *= 2){
        var index = 0;//第一組的起始索引
        while( 2 * i  + index <= len){
            index += 2 * i;
            merge(arr, index - 2 * i, index - i, index);
        }
        //說明剩餘兩個小組，但其中一個小組數據的數量已經不足2的冪次方個
        if(index + i < len){
            merge(arr, index, index + i, len);
        }
    }
    return arr;
}

//利用外排的方式進行結合
function merge(arr, start, mid, end){
    //新建一個輔助數組
    var help = [];
    var l = start, r = mid;
    var i = 0;
    while(l < mid && r < end){
        help[i++] = arr[l] < arr[r] ? arr[l++] : arr[r++];
    }
    while(l < mid){
        help[i++] = arr[l++];
    }
    while(r < end){
        help[i++] = arr[r++];
    }
    for(var j = 0; j < help.length; j++){
        arr[start + j] = help[j];
    }
}

5、快速排序

快速排序實現思路：隨機取出一個值進行劃分，大於該值放右邊，小於該值放左邊（該算法在經典快排的基礎上通過荷蘭國旗思想和隨機思想進行了改造）<br/> 時間複雜度：O(N*logN) <br/> 空間複雜度：O(logN)

function quickSort(arr) {
    if(arr == null || arr.length <= 0){
        return [];
    }
    quick(arr, 0, arr.length - 1);
}

function quick(arr, L, R){
    //遞歸結束條件是L >= R
    if(L < R){
        //隨機找一個值，而後和最後一個值進行交換，將經典排序變爲快速排序
        swap(arr, L + Math.floor(Math.random() * (R - L + 1)), R);
        //利用荷蘭國旗問題得到劃分的邊界，返回的值是小於區域的最大索引和大於區域的最小索引，在這利用荷蘭國旗問題將等於區域部分就不用動了
        var tempArr = partition(arr, L, R, arr[R]);
        quick(arr, L, tempArr[0]);
        quick(arr, tempArr[1], R);
    }
}
//返回值是小於區域最後的索引和大於區域的第一個索引
function partition(arr, L, R, num){
    var less = L - 1;
    var more = R + 1;
    var cur = L;
    while(cur < more){
        if(arr[cur] < num){
            swap(arr, ++less, cur++);
        }else if(arr[cur] > num) {
            swap(arr, --more, cur);
        }else{
            cur++;
        }
    }
    return [less, more];
}
function swap(arr, i, j){
    var temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}

6、堆排序

堆排序思路：<br/>1.讓數組變成大根堆<br/>2.把最後一個位置和堆頂作交換<br/>3.則最大值在最後，則剩下部分作heapify，則從新調整爲大根堆，則堆頂位置和該部分最後位置作交換<br/>4.重複進行，直到減完，則這樣最後就調整完畢，整個數組排完序（爲一個升序）<br/> 時間複雜度:O(N * logN)<br/> 空間複雜度:O(1)

function heapSort(arr) {
    if(arr == null || arr.length <= 0) {
        return [];
    }

    //首先是創建大頂堆的過程
    for(var i = 0; i < arr.length; i++) {
        heapInsert(arr, i);
    }
    var size = arr.length;//這個值用來指定多少個數組成堆，當獲得一個排序的值後這個值減一
    //將堆頂和最後一個位置交換
    /**
     * 當大頂堆創建完成後，而後不斷將最後一個位置和堆頂交換；
     * 這樣最大值就到了最後，則剩下部分作heapify，從新調整爲大根堆，則堆頂位置和倒數第二個位置交換，重複進行，直到所有排序完畢*/
    //因爲前面已是大頂堆，因此直接交換
    swap(arr, 0, --size);
    while(size > 0) {
        //從新變成大頂堆
        heapify(arr, 0, size);
        //進行交換
        swap(arr, 0, --size);
    }
}

//加堆過程當中
function heapInsert(arr, index) {
    //比較當前位置和其父位置，若大於其父位置，則進行交換，並將索引移動到其父位置進行循環，不然跳過
    //結束條件是比父位置小或者到達根節點處
    while(arr[index] > arr[parseInt((index - 1) / 2)]){
        //進行交換
        swap(arr, index, parseInt((index - 1) / 2));
        index = parseInt((index - 1) / 2);
    }
}
//減堆過程
/**
 * size指的是這個數組前多少個數構成一個堆
 * 若是你想把堆頂彈出，則把堆頂和最後一個數交換，把size減1，而後從0位置經歷一次heapify，調整一下，剩餘部分變成大頂堆*/
function heapify(arr, index, size) {
    var left = 2 * index + 1;
    while(left < size) {
        var largest = (left + 1 < size && arr[left] < arr[left + 1]) ? left + 1 : left;
        largest = arr[index] > arr[largest] ? index : largest;

        //若是最大值索引和傳進來索引同樣，則該值到達指定位置，直接結束循環
        if(index == largest) {
            break;
        }

        //進行交換，並改變索引和其左子節點
        swap(arr, index, largest);
        index = largest;
        left = 2 * index + 1;
    }
}

function swap(arr, i, j) {
    var temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}

7、桶排序

桶排序會經歷三次遍歷：準備一個數組、遍歷一遍數組、重構一遍數組，是非基於比較的排序，下面以一個問題來闡述其思路。<br/> 問題：<br/> 給定一個數組，求若是排序以後，相鄰兩個數的最大差值，要求時間複雜度O(N),且要求不能用基於比較的排序<br/>
思路：<br/>1.準備桶：數組中有N個數就準備N+1個桶<br/>2.遍歷一遍數組，找到最大值max和最小值min
。若min = max，則差值=0；若min≠max，則最小值放在0號桶，最大值放在N號桶，剩下的數屬於哪一個範圍就進哪一個桶<br/>3.根據鴿籠原理，則確定有一個桶爲空桶，設計該桶的目的是爲了否認最大值在一個桶中，則最大差值的兩個數必定來自於兩個桶，但空桶兩側並不必定是最大值<br/>4.因此只記錄全部進入該桶的最小值min和最大值max和一個布爾值表示該桶有沒有值<br/>5.而後遍歷這個數組，若是桶是空的，則跳到下一個數，若是桶非空，則找前一個非空桶，則最大差值=當前桶min - 上一個非空桶max，用全局變量更新最大值<br/> 時間複雜度：O(N)<br/> 空間複雜度：O(N)

function maxGap(arr) {
    if(arr == null || arr.length <= 0) {
        return 0;
    }
    var len = arr.length;
    var max = -Infinity, min = Infinity;
    //遍歷一遍數組,找到最大值max和最小值min
    for(var i = 0; i < len; i++) {
        max = max > arr[i] ? max : arr[i];
        min = min > arr[i] ? arr[i] : min;
    }

    //若min = max,則差值爲0;
    if(min == max) {
        return 0;
    }

    var hasNum = new Array(len + 1);
    var mins = new Array(len + 1);
    var maxs = new Array(len + 1);

    var bid = 0;//指定桶的編號

    for(var i = 0; i < len; i++) {
        bid = bucket(arr[i], min, max, len);//得到該值是在哪一個桶//因爲有N+1個桶，因此間隔就是N個，因此此處除以的是len，而後經過這個函數獲得應該放到哪一個桶裏
        maxs[bid] = hasNum[bid] ? Math.max(arr[i], maxs[bid]) : arr[i];
        mins[bid] = hasNum[bid] ? Math.min(arr[i], mins[bid]) : arr[i];
        hasNum[bid] = true;
    }

    var res = 0;
    var lastMax = maxs[0];

    for(var i = 0; i < len + 1; i++) {
        if(hasNum[i]) {
            res = Math.max(mins[i] - lastMax, res);
            lastMax = maxs[i];
        }
    }
    return res;
}

//得到桶號
//這個函數用於判斷在哪一個桶中，參數分別爲值、最小值、最大值、桶間隔
function bucket(value, min, max, len) {
    return parseInt((value - min) / ((max - min) / len));
}

歡迎老鐵們加羣或者私聊