数据结构之集合

这是我参与更文挑战的第19天，活动详情查看：更文挑战

什么是集合

集合是由一组无序且唯一（即不能重复）的项组成的。也可以将集合看成一个既没有重复元素，也没有顺序概念的数组。

实现集合

我们使用对象来表示集合。 使用对象来实现集合，因为javaScript的对象不允许一个键指向两个不同的属性，所以可以保证集合里的元素都是唯一的。集合的一些方法：

• add(value): 向集合添加一个新的项。
• remove(value): 从集合移除一个值。
• has(value): 如果值在集合中，返回true，否则返回false。
• clear(): 移除集合中的所有项。
• size(): 返回集合所包含元素的数量。与数组的length属性相似。
• values(): 返回一个包含集合中所有值的数组。 以es6的Set类的实现为基础：

function Set () {
    let items = {}
    
    // has方法
    this.has = function (value) {
        return items.hasOwnProperty(value)
    }
    this.add = function (value) {
        // 添加之前先检查是否已经存在
        if(!this.has(value)){
            items[value] = value
            return true
        }
        return false
        // 返回true表示添加成功，false表示添加失败
    }
    this.remove = function (value) {
        // 检查要移除的值是否存在集合中
        if(this.has(value)) {
            delete items[value]
            return true
        }
        return false
    }
    this.clear = function () {
        items = {}
    }
    this.size = function () {
        return Object.keys(items).length
    }
    this.values = function () {
        return Object.keys(items)
    }
}

使用集合

let set = new Set()

set.add(1)
console.log(set.values()) // ['1']
console.log(set.has(1)) // true
console.log(set.size()) // 1

set.add(2)
console.log(set.values()) // ['1', '2']
console.log(set.has(2)) // true
console.log(set.size()) // 2

set.remove(1)
console.log(set.values()) // ['2']

集合的操作

• 并集：对于给定的两个集合，返回一个包含两个集合中所有元素的新集合。
• 交集：对于给定的两个集合，返回一个包含两个集合中共有元素的新集合。
• 差集：对于给定的两个集合，返回一个包含所有存在于第一个集合且不存在于第二个集合的元素的新集合。
• 子集：验证一个给定的集合是否是另一个集合的子集。 并集的实现

// 并集的最终结果是返回一个新集合
this.union = function (otherSet) {
    let unionSet = new Set()
    // 拿到该集合的所有值，遍历所有值添加到新声明的集合中
    let values = this.values()
    for (let i = 0; i < values.length; i++) {
        unionSet.add(values[i])
    }
    // 拿到传进来的集合的所有值，遍历所有值添加到新声明的集合中
    values = othereSet.values()
    for (let i = 0; i < values.length; i++) {
        unionSet.add(values[i])
    }
    return unionSet
}

交集的实现

// 交集的最终结果是返回一个新集合
this.intersection = function (otherSet) {
    let intersectionSet = new Set()
    // 拿到该集合的所有值，遍历每一项将otherSet集合中也存在的项添加到新集合中返回
    let values = this.values()
    for (let i = 0; i < values.length; i++) {
        if(otherSet.has(values[i])){
            intersectionSet.add(values[i])
        }
    }
   
    return intersectionSet
}

差集的实现

// 差集的最终结果是返回一个新集合
this.difference = function (otherSet) {
    let differenceSet = new Set()
    // 拿到该集合的所有值，遍历每一项将otherSet集合中不存在的项添加到新集合中返回
    let values = this.values()
    for (let i = 0; i < values.length; i++) {
        if(!otherSet.has(values[i])){
            differenceSet.add(values[i])
        }
    }
   
    return differenceSet
}

子集的实现 判断A是否是B的子集

// 子集返回布尔值
this.subset = function (otherSet) {
    // 当前集合的元素的数量大于传进来的集合的元素数量的话，必然不是其的子集 返回false
    if(this.size() > otherSet.size()) {
        return false
    } else {
        let values = this.values()
        // 遍历当前集合的所有元素，如果在otherSet集合中不存在的话则返回false
        for(let i = 0; i < values.length; i++) {
            if(!otherSet.has(values[i])){
                return false
            }
        }
        return true
    }
    
}