实现集合类

class Set {
    constructor() {
        this.items = {}
    }

    /**
     * 向集合添加一个新元素
     * @param {*} element 
     */
    add(element) {
        if (!this.has(element)) {
            this.items[element] = element
            return true
        }
        return false
    }

    /**
     * 从集合移除一个元素
     * @param {*} element 
     */
    delete(element) {
        if (this.has(element)) {
            delete this.items(element)
            return true
        }
        return false
    }

    /**
     * 如果元素在集合中，返回 true，否则返回 false
     * @param {*} element 
     */
    has(element) {
        return Object.prototype.hasOwnProperty.call(this.items, element)
    }

    /**
     * 移除集合中的所有元素
     */
    clear() {
        this.items = {}
    }

    /**
     * 返回集合所包含元素的数量。
     */
    size() {
        return Object.keys(this.items).length
    }

    /**
     * 返回一个包含集合中所有值（元素）的数组
     */
    values() {
        return Object.values(this.items)
    }
}

并集

对于给定的两个集合，返回一个包含两个集合中所有元素的新集合

/**
 * 并集
 * @param {*} otherSet 
 */
union(otherSet) {
    const unionSet = new Set();
    this.values().forEach(element => unionSet.add(element));
    otherSet.values().forEach(element => unionSet.add(element))
    return unionSet
}

交集

对于给定的两个集合，返回一个包含两个集合中共有元素的新集合。

/**
 * 交集
 * @param {*} otherSet 
 */
intersection(otherSet) {
    const intersectionSet = new Set();
    const values = this.values();
    for (let i = 0; i < values.length; i++) {
        if (intersectionSet.has(values[i])) {
            intersectionSet.add(values[i])
        }
    }
    return intersectionSet
}

差集

对于给定的两个集合，返回一个包含所有存在于第一个集合且不存在于第二个集合的元素的新集合

/**
 * 差集
 * @param {*} otherSet 
 */
difference(otherSet) {
    const differenceSet = new Set();
    const values = this.values();

    for (let i = 0; i < values.length; i++) {
        if (!otherSet.has(values[i])) {
            differenceSet.add(values[i])
        }
    }
    return differenceSet
}

子集

验证一个给定集合是否是另一集合的子集。

/**
 * 子集
 * @param {*} otherSet 
 */
isSubsetOf(otherSet) {
    if (this.size() > otherSet.size()) {
        return false
    }

    const values = this.values();
    for (let i = 0; i < values.length; i++) {
        if (!otherSet.has(values[i])) {
            return false
        }
    }
    return true
}