集合

2024-02-16 08:33:52

集合通常是一组无序的，不能重复的元素构成，常见的实现方式是哈希表

集合可以看成是一个特殊的数据：

里面的元素没有顺序，也不能重复
没有顺序意味着不能通过下标值进行访问，不能重复意味着相同的对象在集合中只会存在一份

集合的操作

<1> add(value)：向集合添加一个新的项

<2> remove(value)：从集合移除一个值

<3> has(value)：如果值在集合中，返回true，否则返回false

<4> clear()：移除集合中的所有的项

<5> size()：返回集合所包含元素的数量，与数组的length属性类似

<6> values()：返回一个包含集合中所有值的数组

操作方法的封装

 //封装集合类
    function Set() {
        this.items = {}
        //add方法
        Set.prototype.add = function (value) {
            //判断当前集合中是否包含元素
            if (this.has(value)) return false
            //将元素添加到集合中
            this.items[value] = value
            return true
        }
        //has方法
        Set.prototype.has = function (value) {
            return this.items.hasOwnProperty(value)
        }
        //remove方法
        Set.prototype.remove = function (value) {
            //判断集合中是否有这个元素
            if (!this.has(value)) return false
            //如果包含
            delete this.items[value]
            return true
        }
        //clear方法
        Set.prototype.clear = function () {
            this.items = {}
        }
        //size方法
        Set.prototype.size = function () {
            return Object.keys(this.items).length
        }
        //values方法
        Set.prototype.values = function () {
            return Object.keys(this.items)
        }
    }

集合间的操作

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

交集：对于给定的两个集合，返回一个包含两个集合*有元素的新集合

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

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

1、并集

       //并集
        Set.prototype.union = function (otherSet) {
            var unionSet = new Set()
            //将集合中的元素添加到新集合中
            var values = this.values()
            for (var i = 0; i < values.length; i++) {
                unionSet.add(values[i])
            }
            //取出旧集合的元素，判断是否需要添加到新集合
            values = otherSet.values()
            for (var i = 0; i < values.length; i++) {
                unionSet.add(values[i])
            }
            return unionSet
        }

测试

  var setA = new Set()
    var setB= new Set()
    setA.add('a')
    setA.add('b')
    setA.add('c')
    setB.add('d')
    setB.add('e')
    setB.add('f')
    //两个集合的并集
    alert(setA.union(setB).values())

2、交集

//交集
        Set.prototype.intersection = function (otherSet) {
            var intersectionSet = new Set()
            //从A中取出元素判断是否在B中
            var values = this.values()
            for (var i = 0; i < values.length; i++) {
                var item = values[i]
                if(otherSet.has(item)) {
                    intersectionSet.add(item)
                }
            }
            return intersectionSet
        }

测试：

  var setA = new Set()
    var setB = new Set()
    setA.add('a')
    setA.add('b')
    setA.add('c')
    setB.add('b')
    setB.add('c')
    setB.add('f')
    //两个集合的并集
    alert(setA.intersection(setB).values())

3、差集

//差集
        Set.prototype.difference= function (otherSet) {
            var differenceSet = new Set()
            //从A中取出元素判断是否在B中
            var values = this.values()
            for (var i = 0; i < values.length; i++) {
                var item = values[i]
                if (!otherSet.has(item)) {
                    differenceSet.add(item)
                }
            }
            return differenceSet
        }

测试：

 var setA = new Set()
    var setB = new Set()
    setA.add('a')
    setA.add('b')
    setA.add('c')
    setB.add('b')
    setB.add('c')
    setB.add('f')
    //两个集合的并集
    alert(setA.difference(setB).values())

4、子集

 //子集
        Set.prototype.subset = function (otherSet) {
            //遍历A中所有元素判断是否都在B中存在如果不存在返回false
            var values = this.values()
            for (var i = 0; i < values.length; i++) {
                var item = values[i]
                if (!otherSet.has(item)) return false
            }
            return true
        }

测试：

   var setA = new Set()
    var setB = new Set()
    setA.add('b')
    setA.add('c')
    setB.add('a')
    setB.add('b')
    setB.add('c')
    //两个集合的并集
    alert(setA.subset(setB))

码农公寓