前端常见算法

很多初学者可能认为算法都是后台的事，学前端不用学算法，这是个误区！！今天整理了一些前端应该了解的算法知识；

排序

一、冒泡排序
原理：每一次对比相邻两个数据的大小，小的排在前面，如果前面的数据比后面的大就交换这两个数的位置。

function bubbleSolt( arr ){

    var len = arr.length;
    //外面的循环是控制了循环周期数，里面的循环则是项与项之间的排序比较。
    for( var i=0; ifor( var j=0; j1-i; j++ ){
            if( arr[j]>arr[j+1] ){  // 相邻元素两两对比
                var temp = arr[j+1];
                arr[j+1] = arr[j];
                arr[j] = temp;
            }
        }
    }
    return arr;
}

二、快速排序
原理:先找到一个基准点（一般指数组的中部），然后数组被该基准点分为两部分，依次与该基准点数据比较，如果比它小，放左边；反之，放右边。左右分别用一个空数组去存储比较后的数据。最后递归执行上述操作，直到数组长度<=1;

function quickSort( arr ){

    if( arr.length<=1 ){
        return arr;
    }

    var mid = Math.floor( arr.length/2 );
    var midItem = arr.splice( mid, 1 )[0];
    var left = [];
    var right = [];

    for( var i=0; i<arr.length; i++ ){
        if( arr[i]else{
            right.push( arr[i] );
        }
    }
    return quickSort( left ).concat( midItem, quickSort( right ) );
}

三、插入排序
原理:首先对前两个数据从小到大比较。接着将第三个数据与排好的前两个数据比较，将第三个数据插入合适的位置。以此类推。

function insertSort(arr){
    var temp, j;
    for(var i=1; i<arr.length; i++){
           temp =arr[i];
           j=i;
           while(j>0 && arr[j-1]>temp){
                arr[j]=arr[j-1];
                j--;
           }
           arr[j]=temp;
    }
    return arr;
}

四、归并排序
原理:把一个数组分为两个数组，左边排好序，右边排好序，然后合并到一起排序；

function mergeSort( arr ){
    // 设置终止的条件
    if( arr.length<2 ){
        return arr;
    }
    //设立中间值
    var mid = Math.floor( arr.length/2 );
    var left = arr.slice( 0,mid );
    var right = arr.slice( mid );

    if( left == "undefined" && right == "undefined" ){
        return false;
    }

    return merge(mergeSort(left), mergeSort(right));

}

function merge( left, right ){
    var result = [];

    while( left.length && right.length ){

        if( left[0] <= right[0] ){
            //把left的左子树推出一个，然后push进result数组里
            result.push( left.shift() );
        }else{
            //把right的左子树推出一个，然后push进result数组里
            result.push( right.shift() );
        }
    }
    //经过上面一次循环，只能左子列或右子列一个不为空，或者都为空
    while( left.length ){
        result.push( left.shift() );
    };
    while( right.length ){
        result.push( right.shift() );
    }
    return result;
}

字符串操作

一、判断回文字符串
回文字符串,就是一个字符串,从左到右读和从右到左读是完全一样的,比如aba。

function palindrome(str){
    // \W匹配任何非单词字符。等价于“[^A-Za-z0-9_]”。
    var re = /[\W_]/g;
    // 将字符串变成小写字符,并干掉除字母数字外的字符
    var lowRegStr = str.toLowerCase().replace(re,'');
    // 如果字符串lowRegStr的length长度为0时，字符串即是palindrome
    if(lowRegStr.length===0) return true;
    // 如果字符串的第一个和最后一个字符不相同，那么字符串就不是palindrome
    if(lowRegStr[0]!=lowRegStr[lowRegStr.length-1]) return false;
    //递归
    return palindrome(lowRegStr.slice(1,lowRegStr.length-1));
}

二、翻转字符串
思路一：反向遍历字符串

function resverseString( str ){

    var temp = "";
    for( var i = arr.lenght-1; i>=0; i-- ){
        temp += str[i];
        return temp;
    }
}

思路二：转化成array操作

function( str ){

    var arr = str.split("");
    var i = 0, j=arr.length-1;
    while( ireturn arr.join("");
}

生成指定长度随机字符串（可用来生成验证码）

function randomString( n ){

    var str = "abcdefghijklmnopqrstuvwxyz";
    var temp = "";
    for( var i=0; iMath.round( Math.random()*str.length ));
    }
    return temp;
}

统计字符串中次数最多字母

function findMaxCode( str ){

        var json = {};

        for( var i =0; iif( !json[ str.charAt(i) ] ){
                json[ str.charAt(i) ] = 1;
            }else{
                json[ str.charAt(i) ] += 1; 
            }
        }

        var code = "",num = 0;

        for( var key in json ){
            if( json[key] > maxValue ){
                num = json[key];
                code = key;
            }
        }

        alert('出现次数最多的是:'+code+'出现'+num+'次');
    }

数组操作

数组去重

function unique( arr ){

    var obj = {};
    var result = [];

    for( var i in arr ){
        if( !obj[ arr[i] ] ){
            obj[ arr[i] ] = true;
            result.push( arr[i] );
        }
    }
    return result;
}

数组中最大差值

function getMaxProfit( arr ){

var min = arr[0];
var max = arr[0];

for( var i =0; i< arr.length, i++ ){
    if( arr[i]<min ){
        min = arr[i];
    }
    if( arr[i]>max ){
        max = arr[i];
    }
}

return max-min;
}

其它

阶乘
非递归实现

function factorialize(num) {
var result = 1;
         if(num < 0) return -1;
         if(num == 0 || num == 1) return 1;
         while(num>1) {
         result *= num--;
    }
    return result;
}

递归实现

function factorialize(num) {
    var result = 1;
    if(num < 0) return -1;
    if(num == 0 || num == 1) return 1;
    if(num > 1) return num*factorialize(num-1);
}