js 简单算法

1. 嵌套数组打平并且去重

    var arr = [3,2,4,5,6,1,5,4,[9,5,3,2,[10,4,6]]];
    var obj = {};//去重标识
    function test(data) {
        var newArr = [];
        for ( var i in data) {
            if (data[i] instanceof Array) {
                return  [].concat(newArr,test(data[i]));
            }else{
                if(!obj[data[i]]) {
                    obj[data[i]] = true;
                    newArr.push(data[i]);
                }
            }
        }
        return newArr;
    }
    var data = test(arr);
    console.log(data)//[3, 2, 4, 5, 6, 1, 9, 10]

2.冒泡排序，从数组中第一个数开始，依次遍历数组中的每一个数，通过相邻比较交换，每一轮循环下来找出剩余未排序数的中的最大数并”冒泡”至数列的顶端。

let list = [ 10, 8, 11, 12, 3];

function sorts(data) {
  let len = data.length;
    for(let j = 0; j < len; j ++) {
      if (data[j] > data[j + 1] ) {
        let val = data[j];
        data[j] = data[j + 1];
        data[j + 1] = val;
      }
    }
  return data;
}

console.log(sorts(list));

 

3.快速排序,算法参考某个元素值，将小于它的值，放到左数组中，大于它的值的元素就放到右数组中，然后递归进行上一次左右数组的操作，返回合并的数组就是已经排好顺序的数组了。

    var arr = [10,20,9,7,30,1,5];
    function fun(data) {
        var len = data.length;
        if (len <= 1) {
            return data;
        }
        var num = data[0];//参考元素
        var left = [];
        var right = [];
        for( var i = 1; i < len; i++) {
            if (data[i] < num ) {
                left.push(data[i]);
            }else{
                right.push(data[i]);
            }
        }
        return [].concat(fun(left), [num], fun(right));
    }
    console.log(fun(arr)); //[1, 5, 7, 9, 10, 20, 30]

 

4. 树形结构数据，根据子级数据的 某个字段，来获取所有的父级

例如：antd 的 联级选择插件，回显数据，需要从上到下的每一级数据的id, 然后存数据库的，可能只有一个id, 不是一个数组，这个时候我们需要拿到这个id, 倒推所有父级的id

getInitMenuActive = (id) => {
    const { list } = this.props;
    function fn(data, val) {
      for (let i = 0; i < data.length; i++) {
        if (data[i] && data[i].id === val) {
          return [data[i].id];
        } else
          if (data[i] && data[i].children && data[i].children.length > 0) {
            let ids = fn(data[i].children, val);
            if (ids) {
              return ids.concat(data[i].id);
            }
          }
      }
    }
    let list = fn(list, id);
    return list ? list : [];
  }

5.比较两个数组，然后返回一个新数组，该数组的元素为两个给定数组中所有独有的数组元素。

例如， [1, 2, 3, 5,6], [1, 2, 3, 4, 5] 应该返回 [4,6] 

function diff(arr1, arr2) {
    let arr3 = [...new Set(arr1),...new Set(arr2)];
    return arr3.filter(v => !(arr1.includes(v) && arr2.includes(v)));
}

 

6. 实现 n + n - 1 + n-2 + n-3

function add(n) {
  if (n <= 0) {
    return 0;
  }
  return n + add(n - 1);
}