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;
}
复制代码