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、选择数组的中间值

2、如果选择的值是待搜索值，那么算法执行完毕

3、如果待搜索值比选中值要小，则返回步骤1并在选中值左边的子数组中寻找

4、如果待搜索值比选中值要大，则返回步骤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;
}

判断回文

倒转后相等即回文

function isPalindrome(str) {
	return Array.from(str).reverse().join('') === str;
}