数据结构---集合&&字典

集合

概念

集合比较常见的实现方式是哈希表，集合通常是由一组 无序的，不能重复的元素构成，在计算机中，集合通常表示结构中的元素是不允许重复的

特殊的数组：特殊之处在于，没有顺序，也不能重复，没有顺序意味着不能通过下标值进行访问 相同的对象在集合中回存在一份 （es6中的Set类）

封装集合类

在集合中添加一个items属性，用于保存之后添加到集合中的元素，因为object的keys本身就是一种集合

•    // add方法 添加元素
•    // has方法 检测集合中是否包含某个元素，hasOwnProperty包含返回true,不包含返回false
•  //remove根据元素在集合中删除掉    可以使用delete语句删除元素
• clear清空元素，没有被引用的数据会被浏览器回收掉（垃圾回收机制）
•  size返回集合的长度 Object.keys 以数组方式返回对象中的所有属性名
• 获取结合中所有的值

  //封装集合类
    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) {
            // hasOwnProperty包含返回true,不包含返回false
            return this.items.hasOwnProperty(value)

        }
        //remove根据元素在结合中删除掉
        Set.prototype.remove = function (value) {
            if (!this.has(value)) return false
            //可以使用delete语句删除元素
            delete this.items[value]
            return true
        }
        // clear清空元素
        Set.prototype.clear = function (value) {
            //没有被引用的数据会被浏览器回收掉（垃圾回收机制）
            this.items = {}
        }
        // size返回集合的长度
        Set.prototype.size = function () {
            // Object.keys 以数组方式返回对象中的所有属性名
            return Object.keys(this.items).length
        }
        //获取结合中所有的值
        Set.prototype.values = function () {
            // Object.keys 以数组方式返回对象中的所有属性名
            return Object.keys(this.items)
        }
    }

集合间操作

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

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

差级：给定一个结合，返回一个包含所有存在于第一个集合且不存在于第二个集合中的新集合

子级：验证一个给定集合是否是令一个结合的子集

并集

• 创建一个新的集合，代表两个集合的并集
• 遍历集合1中所有的值，并且添加到新集合中
• 遍历集合2中所有的值，并且添加到新集合中
• 将最终的新集合返回

      Set.prototype.union = function (otherSet) {
            // this： 集合a otherSet 集合b

            // 创建新的集合
            let unionSet = new Set()

            //将a集合中的所有元素添加到新集合中
            let values = this.values()
            for (let i = 0; i < values.length; i++) {
                unionSet.add(values[i])
            }

            // 取出b集合中的元素,判断是否需要加入到新集合
            let val = otherSet.values()
            for (let i = 0; i < val.length; i++) {
                unionSet.add(val[i])
            }
            return unionSet
        }
    

交集

• 创建一个新的集合
• 遍历集合1中的所有元素，判断该元素是否在集合2中
• 同时在集合2中，将元素加入到新集合中
• 最终将新集合返回

   Set.prototype.intersection = function (otherSet) {
            // this： 集合a otherSet 集合b
            // 创建新的集合
            let intersection = new Set()
            // 取出a集合中的元素 判断该元素是否在集合2中 存在将元素加入到新集合中
            let values = this.values()
            for (let i = 0; i < values.length; i++) {
                let items = values[i]
                if (otherSet.has(items)) {
                    intersection.add(items)
                }
            }
            return intersection
        }

差集

• 创建一个新的集合
• 遍历集合1中的所有元素，判断该元素是否在集合2中
• 不存在集合2中，将元素加入到新集合中
• 最终将新集合返回

  Set.prototype.difference = function (otherSet) {
            // this： 集合a otherSet 集合b
            // 创建新的集合
            let difference = new Set()
            // 取出a集合中的元素 判断该元素不存在集合2中 存在将元素加入到新集合中
            let values = this.values()
            for (let i = 0; i < values.length; i++) {
                let items = values[i]
                if (!otherSet.has(items)) {
                    difference.add(items)
                }
            }
            return difference
        }
   

子集

判断集合1是否大于集合2，如果大于肯定不是集合二的子集

不大于的情况下： 判断集合1中的元素是否都在集合2中存在，存在那么是集合2的子集。有一个不存在就不是集合2的子集

   Set.prototype.subSet = function (otherSet) {
            // this： 集合a    otherSet 集合b
            // 创建新的集合
            let subSet = new Set()
            //遍历集合a中的所有元素，如果发现集合a的元素在集合b中不存在返回false
            //如果遍历完了整个集合依然返回false，返回true即可
            let values = this.values()
            for (let i = 0; i < values.length; i++) {
                let items = values[i]
                if (!otherSet.has(items)) {
                    return false
                }

            }
            return true
        }

字典

很多编程语言中对字典和对象区分比较明显，对象通常是在编译期间就确定下来的结构，不可以动态的添加或者删除属性，而字典使用类似于哈希表的数据结构去实现一种可以动态添加数据的结构

• 字典的主要特点是一一对应的关系
• 比如保存一个人的信息，在合适的情况下取出这些信息
• 使用数组的方式[ 18 lisa 1.88]ke一通过下标取出信息
• 使用字典的方式{“age”：18，“name”：“lisa”，height：1.18}可以通过key取出value
• 字典中的key是不可以重复的，而value值是可以重复的，并且字典中的key是无序的
• 有些编程语言中称这种映射关系为字典

    // 创建字典的构造函数
    function Dictionay() {
        // 字典属性
        this.items = {}

        // 字典操作方法
        // 在字典中添加键值对
        Dictionay.prototype.set = function (key, value) {
            this.items[key] = value
        }

        // 判断字典中是否有某个key
        Dictionay.prototype.has = function (key) {
            return this.items.hasOwnProperty(key)
        }

        // 从字典中移除元素
        Dictionay.prototype.remove = function (key) {
            // 1.判断字典中是否有这个key
            if (!this.has(key)) return false

            // 2.从字典中删除key
            delete this.items[key]
            return true
        }

        // 根据key去获取value
        Dictionay.prototype.get = function (key) {
            return this.has(key) ? this.items[key] : undefined
        }

        // 获取所有的keys
        Dictionay.prototype.keys = function () {
            return Object.keys(this.items)
        }

        // 获取所有的value
        Dictionay.prototype.values = function () {
            return Object.values(this.items)
        }

        // size方法
        Dictionay.prototype.size = function () {
            return this.keys().length
        }

        // clear方法
        Dictionay.prototype.clear = function () {
            this.items = {}
        }
    }