6，集合与字典

一、集合结构

1.1.简介

集合比较常见的实现方式是哈希表，这里使用JavaScript的Object类进行封装。

集合通常是由一组无序的、不能重复的元素构成。

• 数学中常指的集合中的元素是可以重复的，但是计算机中集合的元素不能重复。

集合是特殊的数组：

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

实现集合类：

• 在ES6中的Set类就是一个集合类，这里我们重新封装一个Set类，了解集合的底层实现。

• JavaScript中的Object类中的key就是一个集合，可以使用它来封装集合类Set。用{ }

集合常见的操作：

• add（value）：向集合添加一个新的项；

• remove（value）：从集合中移除一个值；

• has（value）：如果值在集合中，返回true，否则返回false；

• clear（）：移除集合中的所有项；

• size（）：返回集合所包含元素的数量，与数组的length属性相似；

• values（）：返回一个包含集合中所有值的数组；

代码实现

集合的属性前面一定要加this!!,当时就忘了在items前面加this

  //封装集合
        function Set() {
            //属性，对象实现
            this.items = {};
            
            //方法
            //1.add
            Set.prototype.add = function(value) {
                //判断在不在集合中
                if(this.has(value)) {
                    return false;
                }else {
                    this.items[value] = value;
                    return true;
                }
            }

            //2.has方法
            Set.prototype.has = function(value) {
                return this.items.hasOwnProperty(value);
            }

            //3.remove方法
            Set.prototype.remove = function(value) {
                //判断在不在
                if(!this.has(value)) {
                    return false;
                }
                delete this.items[value];
                return true;
            }
        
            //4.clear方法
            Set.prototype.clear = function() {
                this.items = {};
            }

            //5.size方法
            Set.prototype.size = function() {
                return Object.keys(this.items).length;
            }

            //6.返回所有元素
            Set.prototype.values = function() {
                return Object.keys(this.items);
            }

        }

1.3.集合间的操作

集合间操作：

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

并集的实现：

实现思路：创建集合C代表集合A和集合B的并集，先将集合A中的所有元素添加到集合C中，再遍历集合B，如果是集合C所没有的元素就把它添加到集合C中。

交集的实现：

实现思路：遍历集合A，当取得的元素也存在于集合B时，就把该元素添加到另一个集合C中。

差集的实现：

实现思路：遍历集合A，当取得的元素不存在于集合B时，就把该元素添加到另一个集合C中。

子集的实现：

实现思路：遍历集合A，当取得的元素中有一个不存在于集合B时，就说明集合A不是集合B的子集，返回false。

            //集合间的操作
            //1.并集
            Set.prototype.union = function(otherset) {
                var set = new Set();
                var values = this.values();
                for(var i = 0; i < values.length; i++) {  //这里values返回的是一个数组
                    set.add(values[i]);
                }

                values = otherset.values();
                for(var i = 0; i < values.length; i++) {  
                    set.add(values[i]);
                }
                
                return set;
            }

            //2.交集
            Set.prototype.intersection = function(otherset) {
                var interset = new Set();
                //遍历a集合,取值
                var values = this.values();
                //遍历值，看看在不在B中,在就加入到新集合
                for(var i = 0; i < values.length; i++){
                    if(otherset.has(values[i])) {
                        interset.add(values[i]);
                    }
                }
                return interset;
            }
            //3.差集
            Set.prototype.difference = function(otherset) {
                var differenceset = new Set();
                //遍历a集合,取值
                var values = this.values();
                //遍历值，看看在不在B中，不在就加入到新集合
                for(var i = 0; i < values.length; i++){
                    if(!otherset.has(values[i])) {
                        differenceset.add(values[i]);
                    }
                }
                return differenceset;
            }

            //4.子集
            Set.prototype.subset = function(otherset) {
                var values = this.values();
                for(var i = 0; i < values.length; i++){
                    if(!otherset.has(values[i])) {
                        return false;
                    }
                }
                return true;
            }