常见算法的小小总结

刚接触算法，以为就是很简单的计算方法。学习了算法之后才知道算法就像是“菜谱”，特定的算法就是菜谱中一道菜的制作流程。

算法：就是定义良好的计算过程，取一个或者一组的值作为输入，并产生一个或者一组的值作为输出。简单来说算法就是一系列的计算步骤，用来将输入数据转化为输出结果。

下面是几道我最近了解到的常见算法题，有些做了简单的解释，如果有兴趣的可以阅读。

 1，找到提供的句子中最长的单词，并计算它的长度（返回的是数字）
   

 findLongestWord("The quick brown fox jumped over the lazy dog");
    function findLongestWord(str){
        var astr=str.split(" ");//字符串转化为数组
        var bstr=astr.sort(function(a,b){
            return b.length- a.length;//数组元素按长度从大到小排序
        });
        var lenMax=bstr[0].length;
        console.log(lenMax);//6
    }

    2.确保字符串的每个单词的首字母都大写，其余小写

  

  titleCase("The quick brown fox jumped over the lazy dog");
    function titleCase(str){
        var astr=str.toLowerCase().split(" ");
        for(var i=0;i<astr.length;i++){
          /*  console.log(astr[i].length);//astr[i]有length*/
            astr[i]=astr[i][0].toUpperCase()+astr[i].substring(1,astr[i].length);
        }
        var string=astr.join(" ");
        console.log(astr);
        console.log(string);
        console.log( astr[1].substring(0,astr[1].length));//astr[i].length结束位置的下一个位置
        console.log( astr[1].substr(0,astr[1].length));//astr[i].length截取的长度
        console.log( astr[1].slice(0,astr[1].length));//astr[i].length结束位置的下一个位置
    }

    3.重复一个指定的字符串num次，num<0返回一个空字符串
   

 repeatStr("abc",3);
    function repeatStr(str,num){
        var astr=str;
        if(num<0){return ""}
        else{
            for(var i=0;i<num-1;i++){
                str+=astr;
            }
              console.log(str);
        }
    }

    4.把一个数组arr按照指定的数组大小size分割成若干个数组块
  

  chunk([0,1,2,3,4,5,6],2);
    function chunk(arr,size){
        var newarr=[];
        for(var i=0;i<arr.length;i+=size){
           /* console.log(i);//0246*/
            var aarr=arr.slice(i,i+size);
            newarr.push(aarr);
        }
        console.log(newarr);//[Array(2), Array(2), Array(2), Array(1)]
    }

    5.计算一个整数的阶乘
    function factorialize(num){
        if(num<1){
            return 1;
        }
        else{
            return num*factorialize(num-1);
        }
    }
    console.log(factorialize(3));// 显示结果，需要能打印这个factorialize(3)
    6.实现千位分隔符
    

//replace() 方法用于在字符串中用一些字符替换另一些字符，或替换一个与正则表达式匹配的子串。
    /*匹配/(\d)(?=(\d{3})+\.)/g数字后面是三个数字或者3的倍数个数字，后面跟小数点。
     d{3})+表示3的倍数个数字，如3个数字6个数字等，?=表示后面一定是3的倍数个数字*/
    function commafy(num){
        return /*num &&*/ num.toString()
                .replace(/(\d)(?=(\d{3})+\.)/g, function($0,$1){
                    return $1+",";
                });
    }
    console.log(commafy(1234567.89));//1,234,567.89

    7.js快排 sort 函数递归算法去做
    function quickSort(a,b){
          return a-b;//[0, 1, 2, 3, 4, 10, 23]
    }
    var arr=[1,3,2,0,23,4,10];
    console.log(arr.sort(quickSort));
    8.数组去重
    /*arr.indexOf()*/
    function select(arr){
        var barr=[];
        for(var i=0;i<arr.length;i++){
            if(barr.indexOf(arr[i])==-1){
                barr.push(arr[i]);
            }
        }
        console.log(barr);
    }
    select([1,22,15,2,3,1,22,6,10,22]);
    /*
    

推荐使用
    1.创建一个新的数组存放结果
    2.创建一个空对象
    3.for循环时，每次取出一个元素与对象进行对比，如果这个元素不重复，则把它存放到结果数组中，
    同时把这个元素的内容作为对象的一个属性，并赋值为1，存入到第2步建立的对象中。
    说明：至于如何对比，就是每次从原数组中取出一个元素，然后到对象中去访问这个属性，
    如果能访问到值，则说明重复。*/
    Array.prototype.unique = function(){
        var res = [];
        var json = {};
        for(var i = 0; i < this.length; i++){
            if(!json[this[i]]){
                res.push(this[i]);
                json[this[i]]=true;
            }
        }
        return res;
    };
    var arr = [112,112,34,'你好',112,112,34,'你好','str','str1'];
    console.log(arr.unique());

    9.查找字符串里面那个字符最多，有几个(求字符串'nininihaoa'中出现次数最多字符)
    

 var str = "nininihaoa";
    var o = {};
    for (var i = 0, length = str.length; i < length; i++) {
        var char = str.charAt(i);
        if (o[char]) {
            o[char]++; //次数加1
        } else {
            o[char] = 1; //若第一次出现，次数记为1
        }
    }
    console.log(o); //输出的是完整的对象，记录着每一个字符及其出现的次数
    //遍历对象，找到出现次数最多的字符的次数
    var max = 0;
    for (var key in o) {
        if (max < o[key]) {
            max = o[key]; //max始终储存次数最大的那个
        }
    }
    for (var key in o) {
        if (o[key] == max) {
//console.log(key);
            console.log("最多的字符是" + key);
            console.log("出现的次数是" + max);
        }
    }

    10.平衡数组[100,10000,100000,1000,10] 

var a=[100,10000,100000,1000,10];
    function showNum(num1,num2){
        return num2-num1;//从大到小
    }
    a= a.sort(showNum);
    console.log(a);//[100000, 10000, 1000, 100, 10]
    var list=[];
    var index=0;
    addNum();     //[100, 10000, 100000, 1000, 10]
    function addNum(){
        if(index%2==0){
            list.push(a[index]);
        }
        else{
            list.unshift(a[index]);//向数组的开头添加一个元素
        }
        index++;
        if(index>= a.length){
            console.log(list);
            return;
        }
        addNum();//递归算法，调用自身
    }

    11.相对路径转化为绝对路径
    function getAbsoluteUrl(url){
        var img = new Image();
        img.src = url; // 设置相对路径给Image, 此时会发送出请求
        url = img.src; // 此时相对路径已经变成绝对路径
        img.src = null; // 取消请求
        return url;
    }
    /*console.log(getAbsoluteUrl("../image.jpg"));*/
    12.数组扁平化   [1,[2,3,[4]]]---[1,2,3,4]
  

 function flatten(arr){
       var res=[];
       for(var i=0;i<arr.length;i++){
           if(Array.isArray(arr[i])){
               res=res.concat(flatten(arr[i]))
           }
           else{
               res.push(arr[i]);
           }
       }
       return res;
   }
console.log(flatten([1,[2,3,[4]]]));