数组去重的算法总结

利用Set ()+Array.from ()：时间复杂度O(n)，空间复杂度O(n)
利用两层循环+数组的splice方法：时间复杂度O(n^2)，空间复杂度O(1)
利用数组的indexOf方法：时间复杂度O(n^2)，空间复杂度O(n)
利用数组的includes方法：时间复杂度O(n^2)，空间复杂度O(n)
利用数组的filter ()+indexOf ()：时间复杂度O(n^2)，空间复杂度O(n)
利用Map ()：时间复杂度O(n)，空间复杂度O(n)

//利用Set()+Array.from()
function unique(arr) {
  return Array.from(new Set(arr));
}

//利用两层循环+数组的splice方法
function unique(arr) {
  for (let i = 0; i < arr.length; i++) {
    for (let j = i + 1; j < arr.length; j++) {
      if (arr[i] === arr[j]) {
        //如果第一个等于第二个，splice方法删除第二个
        arr.splice(j, 1);
        j--;
      }
    }
  }
  return arr;
}

//利用数组的indexOf方法
function unique(arr) {
  let result = []; //新建一个数组
  for (let i = 0; i < arr.length; i++) {
    //遍历旧数组
    if (result.indexOf(arr[i]) === -1) {
      //如果新数组中没有旧数组中的元素，则存入新数组中
      result.push(arr[i]);
    }
  }
  return result;
}

//利用数组的includes方法
function unique(arr) {
  let result = []; //新建一个结果数组
  for (let item of arr) {
    //遍历需要去重的数组
    if (!result.includes(item)) {
      //如果结果数组中不包含当前元素，则存入结果数组中
      result.push(item);
    }
  }
  return result;
}

//利用数组的filter()+indexOf()
function unique(arr) {
  return arr.filter((item, index) => {
    //返回第一次出现该元素的索引是否等于当前索引，即过滤掉后面重复出现的元素
    return arr.indexOf(item) === index;
  });
}

//利用Map()
function unique(arr) {
  let map = new Map(); //创建一个Map对象
  let result = []; //创建一个结果数组
  for (let item of arr) {
    //遍历需要去重的数组
    if (!map.has(item)) {
      //如果Map对象中没有该元素，则存入Map对象和结果数组中
      map.set(item, true);
      result.push(item);
    }
  }
  return result;
}