Javascript常見算法整理

最近在看《學習Javascript數據結構與算法》，整理一下書中所提到的排序算法。

排序算法

冒泡排序

原理：比較相鄰的項，若是第一個比第二個大，則交換他們

    
var length = array.length;
        for(var i = 0; i < length; i++){
            for(var j = 0; j < length - i - 1; j++){
                if (array[j] > array[j + 1]) {
                    //es6語法
                    [array[j],array[j+1]] = [array[j+1],array[j]]
                }
            }
        }
    複製代碼

選擇排序

原理：找到數據結構中最小值並將其放在第一位，接着找到第二小的值放在第二位，以此類推

    
var length = array.length,indexMin;
        for (var i = 0; i < length; i++) {
            for (var j = i; j < length; j++) {
                if (array[i] > array[j]) {
                    [array[j],array[i]] = [array[i],array[j]]
                }
            }
        }
    複製代碼

插入排序

原理：假定第一項已經排序，和第二項進行比較，按照大小調整位置，第三項和頭兩項分別進行比較，調整位置，第四項和前三項分別比較，調整位置，以此類推

    
var length = array.length, j, temp;
        for (var i = 1; i < length; i++) {
            j = i;
            temp = array[j];
            while ( j > 0 && array[j - 1] > temp) {
                array[j] = array[j - 1];
                j--
            }
            array[j] = temp;
        }
    複製代碼

歸併排序

原理：降原始數組切分紅較小的數組，知道每一個小數組只有一個位置，接着降小數組歸併成大數組，知道最後只有一個排序完畢的大數組

    
function merge(left,right) {
            var result = [];
            while (left.length && right.length) {
                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;
        }
        function mergeSort(array) {
            if (array.length < 2) {
                return array;
            }
            var length = array.length;
            var midle = parseInt(array.length / 2);
            var left = array.slice(0,midle);
            var right = array.slice(midle,length);
            return merge(mergeSort(left),mergeSort(right));
        }
    複製代碼

快速排序

• 首先選擇數組中間一項做爲主元
• 建立兩個指針，左邊一個指向數組第一個項，右邊一個指向數組最後一個項。移動左指針知道咱們找到一個比主元大的元素，接着移動右指針知道咱們找到一個比主元小的元素，而後交換他們，重複這個過程，知道左指針超過了右指針。整個過程將使得比主元小的值都排在主元以前，而比主元大的值都排在主元以後。這一步叫劃分操做。
• 接着，算法對劃分後的小數組（較主元小的值組成的子數組，以及較主元大的值組成子數組）重複以前的兩個步驟，直到數組已徹底排序

    
function quick (array,left,right) {
            var index;
            if (array.length > 1) {
                index = partition(array,left,right);
                if (left < index - 1) {
                    quick(array,left,index - 1)
                }
                if (index < right) {
                    quick(array,index,right);
                }
            }
        }
        function partition (array,left,right) {
            var pivot = array[Math.floor((right + left) / 2)],
                i = left,
                j = right;
            while(i <= j) {
                while (array[i] < pivot) {
                    i++;
                }
                while (array[j] > pivot) {
                    j--;
                }
                if (i <= j) {
                    [array[i],array[j]] = [array[j],array[i]]
                    i ++;
                    j --;
                }
            }
            return i;
        }
        quick(array,0,array.length - 1);
    複製代碼

搜索算法

順序搜索

遍歷數組，逐個對比

    
        function sequentialSearch(array, item) {
            var length = array.length;
            for (var i = 0; i < length; i++) {
                if (array[i] === item) {
                    return i;
                }
            }
            return -1;
        }
    

二分搜索

**要求被搜索值已經排序**

一、選擇數組的中間值

二、若是選擇的值是待搜索值，那麼算法執行完畢

三、若是待搜索值比選中值要小，則返回步驟1並在選中值左邊的子數組中尋找

四、若是待搜索值比選中值要大，則返回步驟1並在選中值右邊的子數組中尋找

function binarySearch (array,item) {
    var low = 0,
        high = array.length - 1,
        mid,element;
    while (low <= high) {
        mid = Math.floor((low + high) / 2);
        element = array[mid];
        if (element < item) {
            low = mid + 1;
        } else if (element > item) {
            high = mid - 1;
        } else {
            return mid;
        }
    }
    return -1;
}
複製代碼