js算法

1. js实现大整数相加

思路：就是我们算加法的思想，从后往前，逢十进一。如果不先reverse在循环里倒着加其实也是一样的，但是我觉得这么写更浅显易懂，但可能优化方面就不是很好，因为拿长数字做了基准。

    var num1 = 999999999564569;
    var num2 = 666666666;
    function plus(num1, num2){
        var a = num1+'';
        var aa = a.split('').reverse();  //用split拆要是字符串才可以
        var b = num2+'';
        var bb = b.split('').reverse();
        var maxLength = Math.max(aa.length, bb.length); //以长串为基准
        var sum = 0;  //每次的合
        var sumFlag = 0;  //是否要进位
        var arr = [];  //新数组，来存加了之后的数字
        for(var i = 0; i< maxLength; i++){  //补齐短的数字，因为以长的为基准
        //短的是undefined的话parseInt出来是NaN
            if(aa[i] == undefined){
                aa[i] = 0;
            }
            if(bb[i] == undefined){
                bb[i] = 0;
            }
        }

        for(var i = 0; i< maxLength; i++){
            sum = parseInt(aa[i]) + parseInt(bb[i]) + parseInt(sumFlag); 
            //每一位是两个数字及进位相加
            arr[i] = sum;
            sumFlag = 0;
            if(sum > 9){  //如果需要进位
                arr[i] = sum - 10;
                sumFlag = 1;
            }
            if(arr[maxLength-1] == 0 && sumFlag ==1){  
//要考虑到一直加为10进行下去的话最后一次取了0没有给前面补1，就会很多位是0，导致后面取0取消掉
                arr.push(1);
            }

        }

        return arr.reverse().join('').replace(/^0+/g,'');  //翻转过来返回
    }
    var sum = plus(num1,num2);
    console.log(sum);

2.尾递归（尾调用）

尾调用：函数执行的过程中，如果最后是一个函数的调用，即这个调用的返回值被当前函数直接返回。

为什么使用尾调用：在递归过程中，一直在调用栈上增加新的堆栈，但其实没有必要，我们可以直接更新调用栈来使用，性能更优化。

例子：

function f(x){
      return g(x);
}

以下形式不为尾调用：

function f(x){
      let y = g(x);
      return y;
}
//或者
function f(x){
      return g(x) + 1;
}

通过尾调用去优化斐波那契数列和阶乘：

    //尾递归斐波那契数列，传入第几位，结果是这一位的值
    //数列为1，1，2，3，5，8······
      function f(n, a = 0, b = 1){
        if(n < 1){
          return  a;
        }
        return f(n-1, b, a+b);
      }

      console.log(f(6));
      //尾递归阶乘，传入值，返回结果是阶乘后的值
      function p(n, all = 1){
        if(n == 1){
          return all;
        }
        return p(n - 1, n*all);
      }
      console.log(p(5));

3.排序算法

• 冒泡，时间复杂度o(n²)，稳定

      var array = new Array('2','1','4','7','4','8','3','6','4','7');
      var tag; //优化，如果上次没有交换就停止冒泡
      var tem;
      for(var i = 0 ;i < array.length-1 ;i++){
        tag = true;
        for(var j = 0 ;j < array.length-1-i ;j++){
          if(array[j] > array[j+1]){
            tem = array[j];
            array[j] = array[j+1];
            array[j+1] = tem;
            tag = false;
          }
        }
        if(tag){
          break;
        }
      }

• 快排，时间复杂度最差（完全有序）o(n²)，最小o(n*log2n)，不稳定

      var arrBefore = [3,2,4,8,4,7,6,9];

      function sort(arr){
        if(arr.length <=1){
          return arr;
        }
        var middle = Math.floor(arr.length/2);
        var left = [];
        var right = [];
        var center = arr.splice(middle,1)[0];
        for(var i =0;i < arr.length; i++){
          if(arr[i] >= center){
            right.push(arr[i]);
          }else{
            left.push(arr[i]);
          }
        }
        return sort(left) .concat(center,sort(right))
      }
      var arrNew = sort(arrBefore);
      console.log(String(arrNew));

• 插入，默认第一位已经排好序，将无序区间的元素插入有序区间正确的位置，时间复杂度o(n²)，稳定

      var arrBefore = [3,2,5,8,4,7,6,9];
      function sort(arr){
        for(var i = 1; i t && p >= 0){
            arr[p+1] = arr[p]
            p--;
          }
          arr[p+1] = t;
        }
        return arr;
      }
      var arrNew = sort(arrBefore);
      console.log(arrNew);

• 选择，从未排序区间中选择最小的放入已排序区间的最后一个，时间复杂度o(n²)，不稳定

        var arrBefore = [3,2,5,8,4,7,6,9];
        function choose(arr){
          let min = 0;
          let temp = 0;
          for(let i = 0; i < arr.length-1; i++){
            min = i;
            for(let j = i+1; j< arr.length; j++){
              if(arr[j] < arr[min]){
                min = j;
              }
            }
            temp = arr[min];
            arr[min] = arr[i];
            arr[i] = temp;
          }
          return arr;
        }
        let result = choose(arrBefore);
        console.log(result);