JavaScript数据结构与算法——集合

集合

• 一种 无序且唯一 的数据结构
• ES6 中有集合，名为 Set （Set 可以包含 任何 JavaScript 数据类型 作为值，Set结构 不会 添加 重复 的值）
• 集合的常用操作：去重、判断某元素是否在集合中、求交集......

JS 中的集合

// 去重
const arr = [1, 1, 2, 2];
const arr2 = [...new Set(arr)];

// 判断元素是否在集合中
const set = new Set(arr);
const has = set.has(3);

// 求交集
const set2 = new Set([2, 3]);
// 1. 转化为数组 2. filter 方法
const set3 = new Set([...set].filter(item => set2.has(item)));

LeetCode：349 两个数组的交集

给定两个数组 nums1 和 nums2 ，返回 它们的交集 。输出结果中的每个元素一定是 唯一 的。我们可以 不考虑输出结果的顺序 。

示例 1：

输入：nums1 = [1,2,2,1], nums2 = [2,2]

输出：[2]

示例 2：

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

输出：[9,4]

解释：[4,9] 也是可通过的

解题思路：

• 求交集且无序唯一

解题步骤：

• 用集合对 nums1 去重
• 遍历 nums1， 筛选出 nums2 也包含的值

/**
 * @param {number[]} nums1
 * @param {number[]} nums2
 * @return {number[]}
 */
var intersection = function(nums1, nums2) {
    return [...new Set(nums1)].filter(n => (nums2).includes(n))
};

时间复杂度：O(m*n) filter, includes

空间复杂度：O(m) nums1.length

前端与集合：使用 ES6 的 Set

Set 操作

• 使用 Set 对象：new、add、delete、has、size
• 迭代 Set：多种迭代方法、Set 与 Array 互转、求交集/差集

let mySet = new Set();

// 增
mySet.add(1);
mySet.add(1);
mySet.add(5);
mySet.add('some text');
let o = { a: 1, b: 2 };
mySet.add(o);
mySet.add({ a: 1, b: 2 });
// Set(5) {1, 5, 'some text', { a: 1, b: 2 }, { a: 1, b: 2 }}

// 为什么可以添加两个看似一样的对象？
// 对象在内存中的存储地址不一样

// 查
const has = mySet.has(1); // true
const has1 = mySet.has(3); // false
const has2 = mySet.has(5); // true
const has3 = mySet.has('some text'); // true
const has4 = mySet.has(o); // true

// 删
mySet.delete(5);

for (let item of mySet) console.log(item); 
for (let item of mySet.keys()) console.log(item);
for (let item of mySet.values()) console.log(item);
// 1
// some text
// {a: 1, b: 2}
// {a: 1, b: 2}
for (let item of mySet.entries()) console.log(item);
// [1, 1]
// ['some text', 'some text']
// [{a: 1, b: 2}, {a: 1, b: 2}]
// [{a: 1, b: 2}, {a: 1, b: 2}]

// Set 中 key 和 value 一致

// 转化为数组
const myArr = [...mySet];
const myArr1 = Array.from(mySet);

const mySet2 = new Set([1, 2, 3, 4]);
// 交集
const intersection = new Set([...mySet].filter(i => mySet2.has(i)));
// 差集
const difference = new Set([...mySet].filter(i => !mySet2.has(i)));