JS实现集合Set的相关算法

两个数组的交集

给定两个数组，编写一个函数来计算它们的交集

示例：

输入: nums1 = [1,2,2,1], nums2 = [2,2]
输出: [2]

输入: nums1 = [4,9,5], nums2 = [9,4,9,8,4]
输出: [9,4]

说明:
输出结果中的每个元素一定是唯一的。
我们可以不考虑输出结果的顺序。

• Set和Array

//执行用时 :56 ms, 在所有 javascript 提交中击败了99.29%的用户
//内存消耗 :34 MB, 在所有 javascript 提交中击败了71.43%的用户
var intersection = function (nums1, nums2) {
  const set = new Set();
  nums1.forEach(num1 => {
    if (nums2.includes(num1)) {
      set.add(num1)
    }
  });
  return [...set]
};

• Set

//执行用时 :72 ms, 在所有 javascript 提交中击败了57.01%的用户
//内存消耗 :34.1 MB, 在所有 javascript 提交中击败了66.67%的用户
var intersection = function (nums1, nums2) {
  const set = new Set(nums1);
  return Array.from(new Set(nums2.filter(num => set.has(num))));
  //return [... new Set(nums1.filter(item => nums2.includes(item)))] //内存消耗相对更大
};

编写一个算法来判断一个数是不是“快乐数”

一个“快乐数”定义为：对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和，然后重复这个过程直到这个数变为 1，也可能是无限循环但始终变不到 1。如果可以变为 1，那么这个数就是快乐数。

示例：

输入: 19
输出: true
解释: 
12 + 92 = 82
82 + 22 = 68
62 + 82 = 100
12 + 02 + 02 = 1

• Set（循环求平方和）

判断出现的数之前有没有出现过，出现过就会产生循环，就不是快乐数。可以用集合 set 来记录之前出现的数字。

//执行用时 :76 ms, 在所有 javascript 提交中击败了66.78%的用户
//内存消耗 :34.6 MB, 在所有 javascript 提交中击败了87.73%的用户
var isHappy = function (n) {
  var resSet = new Set();
  while (true) {
    if (n == 1) { return true; }
    var sum = 0;
    while (n !== 0) {
      sum += (n % 10) * (n % 10);
      n = Math.floor(n / 10);
    }

    if (resSet.has(sum)) {
      return false;
    }

    resSet.add(sum);
    n = sum;
  }
};

• 数组求平方和

//执行用时 :64 ms, 在所有 javascript 提交中击败了97.09%的用户
//内存消耗 :36.2 MB, 在所有 javascript 提交中击败了25.15%的用户
var isHappy = function (n) {
  var loopArr = []
  while (n !== 1) {
    var arr = []
    while (n !== 0) {
      arr.push(n % 10)
      n = Math.floor(n / 10)
    }
    n = arr.reduce((left, right) => left + right * right, 0)
    var isLoop = loopArr.some(item => item == n)
    if (isLoop) {
      return false
    }
    loopArr.push(n)
  }
  return true

};

存在重复元素

给定一个整数数组，判断是否存在重复元素。如果任何值在数组中出现至少两次，函数返回 true。如果数组中每个元素都不相同，则返回 false

示例：

输入: [1,2,3,1]
输出: true

输入: [1,2,3,4]
输出: false

输入: [1,1,1,3,3,4,3,2,4,2]
输出: true

• 方法一：借用Set判断是否已经存在元素 （或者map、obj）

//执行用时 :68 ms, 在所有 javascript 提交中击败了95.59%的用户
//内存消耗 :40.6 MB, 在所有 javascript 提交中击败了41.49%的用户
var containsDuplicate = function (nums) {
  var arrSet = new Set();
  var res = false;
  nums.forEach(item => {
    if (arrSet.has(item)) {
      res = true;
    }
    arrSet.add(item);
  });
  return res;
};


//执行用时 :76 ms, 在所有 javascript 提交中击败了84.89%的用户
//内存消耗 :42.1 MB, 在所有 javascript 提交中击败了34.27%的用户
var containsDuplicate = function (nums) {
  let obj = {}
  for (let i = 0, length = nums.length; i < length; i++) {
    if (obj[nums[i]]) return true
    obj[nums[i]] = true
  }
  return false
};

• 方法二：去重后比较长度

var containsDuplicate = function (nums) {
  //执行用时 :84 ms, 在所有 javascript 提交中击败了68.49%的用户
  //内存消耗 :40 MB, 在所有 javascript 提交中击败了47.61%的用户
  return nums.length > new Set(nums).size   //return [...new Set(nums)].length!=nums.length;
  
  //执行用时 :72 ms, 在所有 javascript 提交中击败了90.89%的用户
  //内存消耗 :42 MB, 在所有 javascript 提交中击败了36.72%的用户
  /* const map = new Map()
  nums.forEach((item, key) => map.set(item, key))
  return map.size !== nums.length */
};

• 方法二：先排序后比较

var containsDuplicate = function (nums) {
  const len = nums.length;
  if (len < 2) {
    return false;
  }

  nums.sort((a, b) => {
    return a - b;
  })

  for (let i = 0; i < len; i++) {
    if (nums[i] == nums[i + 1]) {
      return true;
    }
  }
  return false;
}

题目来源于leetcode https://leetcode-cn.com/explore