大数相加问题

  function sumString(a, b){
    a = a + '';
    b = n + '';

    var arrA = a.spilt(''),
        arrB = b.spilt(''),
        distance = arrA.length - arrB.length,   // 计算两者的长度差，取最大的那个作为基准点
        len = distance > 0 ? arrA.length : arrB.length,
        carry = 0;        // 表示相加之后的进位

        // 把长度小的那个数组的前面用0补齐，让两者的位数相同
        if (distance > 0){
            for (var i = 0; i < distance; i++) {
              arrB.unshift('0');
            }
        } else {
          for (var i = 0; i < Math.abs(distance); i++) {
            arrA.unshift('0');
          }
        }

        var res = [];
        // 开始从数组的最后一位向前遍历，相同位数对应相加
        for (var i = len - 1; i >= 0; i--) {
          var temp = +arrA[i] + (+arrB[i]) + carry;
          if (temp >= 10) {
            // 6+7=13, 只需要取出最后一位
            carry = 1;
            // 先把数组转换为字符串，然后拿出来最后一位数
            res.push((temp + '')[1]);
          } else {
            carry = 0;
            res.push(temp + '');
          }
        }


        // 将数组转换为字符串输出

        return res.join('').replace(/^0/, '');
  }

URL转换为json对象

// url = ?name=zhangsan&age=18&sex=25
function getQueryObject(url){
  // 参数校验
  url = url == null ? window.location.href : url;
  var search = url.substring(url.lastIndexOf('?') + 1);
  // 开始进行字符串解析name=zhangsan&age=18&sex=25
  // +代表匹配一个或多个，零个肯定是不行的。*代表0个或多个，这里value没有是允许的。那么这里要注意的就是^在单独使用时，代表以什么开头，在中括号里面使用代表不包含的意思
  // 中括号里面的内容相当于是或的意思：表示除了?,&,=这三个字符以外的其他所有字符
  var reg = /([^?&=]+)=([^?&=]*)/g;
  var obj = {};
  // 其中res表示匹配成功的字符串序列，$1，表示第一个（）内所匹配的内容，$2为第二个，依次类推。当我们使用全局匹配时，只要匹配成功的子串最后都会执行一遍function函数
  search.replace(reg, function(res, $1, $2){
    // name=zhangsan,age=18,sex=male
    console.log(res, $1, $2);
    obj[$1] = $2;
  });
  return obj;
}

JSON转换为URL？

 // data={name : 'zhangsan', age : 'lisi'}
  function parseParams(data){
    var key, i, value, tempArr = [];
    for (i in data) {
      key = encodeURIComponent(i);
      value = encodeURIComponent(data[i]);
      tempArr.push(key + '=' + value);
    }
    return tempArr.join('&');
  }

使用两个数组实现一个定长的队列？

JS先奇数后偶数排序

  // v1. 分开写的实现思路
  function sortArray(arr){
    arr.sort((a, b) => {
      // 1. 先把奇数放在前面，把偶数放在后面
      if (a % 2 === 0 && b % 2 === 1) {
        // 如果前面的元素是奇数的话，而且后面的元素是偶数的话，就去交换
        return 1;
      }
    })
    arr.sort((a, b) => {
      // 1. 把前面的那部分奇数，和后面的那部分偶数按照从小到大的顺序排序
      if (a > b && (a % 2 === 1 && b % 2 === 1)) {
        return 1;
      }
      if (a > b && (a % 2 === 0 && b % 2 === 1)) {
        return 1;
      }
    });
  }

  // v2. 代码优化版本
  function sortArray(arr){
    arr.sort((a, b) => {
      if (a % 2 === 0 && b % 2 === 1) {
        return 1;
      }
      if (a > b && (a % 2 === 1 && b % 2 === 1) || (a % 2 === 0 && b % 2 === 1)) {
        return 1;
      }

    });
  }

求数组最长递增子序列长度

/**
 * 求数组最长递增子序列
 * @param arr
 */
function getMaxSequenceNumbers(arr){
    let res = [];
    res.push(arr[0])
    for (let i = 1, len = arr.length; i < len; i++) {
        // 开始处理res
        if (arr[i] > res[res.length - 1]) {
            res.push(arr[i]);
        }
        else {
            // 小于等于的话
            // 需要在res中找到第一个大于arr[i]的元素，然后替换掉这个元素（二分查找）
            let index = binarySearch(res, arr[i]);
            if (index) {
                res[index] = arr[i];
            }
        }
    }

    return res.length;
}

function binarySearch(arr, val) {
    let l = 0, r = arr.length - 1;
    while (l <= r) {
        let mid = Math.floor(l + (r - l) / 2);
        if (val < arr[mid]) {
            r = mid - 1;
        }
        else if (val > arr[mid]) {
            l = mid + 1;
        }
    }

    // 最终的l就是找到的结果,arr中第一个大于val的元素位置
    return l;
}


console.log(getMaxSequenceNumbers([5, 6, 7, 1, 2, 8]));