数据结构与算法（三）之集合，字典（偏向JS）

数据结构（三）

说明：本文基于哔哩哔哩视频【JavaScript数据结构与算法】整理

集合（Set ） es6中包含的类）（通常由哈希表实现） ※ ※ ※ ※

• 特点:无序（没有下标），不允许重复的数组（类似）

• 图示：来自网络

• 常见集合的操作

• add(value)：向集合添加一个新的项。

• remove(value)：从集合移除一个值。

• has(value)：如果值在集合中，返回true，否则返回false。

• clear()：移除集合中的所有项。

• size()：返回集合所包含元素的数量。与数组的length属性类似。

• values()：返回一个包含集合中所有值的数组。

• 集合间的操作

• 并集 A U B

• 交集

• 差集（返回所有存在于第一个集合且不存在于第二个集合的元素的新集合）

• 子集
  操作相关代码

       // 无序，不能重复
        function Set() {
            // 集合的元素  集合
            this.items = {};

            // 集合的操作方法
            Set.prototype.add = function(value) {
                if (this.has(value)) {
                    return false;
                }
                this.items[value] = value;
                return true;
            };
            Set.prototype.has = function(value) {
                return this.items.hasOwnProperty(value);
            };
            Set.prototype.remove = function(value) {
                if (!this.has(value)) {
                    return false;
                }
                delete this.items[value];
                return true;
            };
            Set.prototype.clear = function() {
                this.items = {};
            };
            Set.prototype.size = function() {
                return Object.keys(this.items).length;
            };
            Set.prototype.values = function() {
                return Object.keys(this.items);
            };

            // 两个或者多个集合间的操作
            // 交集
            Set.prototype.union = function(otherSet) {
                // this 集合 A
                // otherSet 集合 B
                // 创建新集合===》  将 A 中的所有元素都添加到 新集合中 ===》 取出 B 所有 元素，判断B中的元素是否在 新集合中已经存在，已经存在则不放进去，不存在则放进去

                var newSet = new Set();

                var value = this.values();
                for (let i = 0; i < value.length; i++) {
                    newSet.add(value[i]);
                }
                var valueB = otherSet.values();
                for (let i = 0; i < valueB.length; i++) {
                    newSet.add(valueB[i]);
                }
                return newSet;
            };
            // 并集
            Set.prototype.intersection = function(otherSet) {
                // this 集合 A
                // otherSet 集合 B
                // 创建新集合===》  将 A 中的所有元素取出===》判断 A中的元素是否存在于 B中，不都存在则不放进去，都存在则放进去

                var newSet = new Set();

                var value = this.values();
                for (let i = 0; i < value.length; i++) {
                    if (otherSet.has(value[i])) {
                        newSet.add(value[i]);
                    }
                }
                return newSet;
            };
            // 差集
            Set.prototype.difference = function(otherSet) {
                // this 集合 A
                // otherSet 集合 B
                // 创建新集合===》  将 A 中的所有元素取出===》判断 A中的元素是否存在于 B中，不都存在则不放进去，都存在则放进去

                var newSet = new Set();

                var value = this.values();
                for (let i = 0; i < value.length; i++) {
                    if (!otherSet.has(value[i])) {
                        newSet.add(value[i]);
                    }
                }
                return newSet;
            };
            // 子集    A 是否是 B 的自己
            Set.prototype.subSet = function(otherSet) {
                // this 集合 A
                // otherSet 集合 B
                // 创建新集合===》  将 A 中的所有元素取出===》判断 A中的元素是否存在于 B中，不存在则不放进去，存在则放进去

                var newSet = new Set();

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

                }
                return true
                    // return newSet;
            };
        }
        var ss = new Set();
        ss.add("aaa");
        ss.add("bbb");
        ss.add("ccc");
        console.log(ss.add("aaa"), "add");
        console.log(ss.has("aaa"), "has");
        console.log(ss, "clear");
        console.log(ss.size(), "size");
        console.log(ss.values(), "values");

        // 集合间的操作
        var ssB = new Set();
        ssB.add("111");
        ssB.add("aaa");
        ssB.add("333");

        const res = ss.union(ssB);
        console.log(res, "union");
        const resB = ss.intersection(ssB);
        console.log(resB, "intersection");
        const resC = ss.difference(ssB);
        console.log(resC, "difference");
        console.log(ss.subSet(ssB), "subSet");

字典（dictionary） ※ ※ ※ ※ ※

• 基于对象实现的方式 ，和集合类似，
• 基于哈希表 实现
• 特点：一一对应，由键（不能重复，无序）值对组成。
• 和 映射 的关系：有些语言中称映射关系 为字典，有些为 map
• 和数组的关系：字典通过 key 找 value，数组通过下标
• 常见的操作
  • set(key,value)：向字典中添加新元素。
  • remove(key)：通过使用键值来从字典中移除键值对应的数据值。
  • has(key)：如果某个键值存在于这个字典中，则返回true，反之则返回false。
  • get(key)：通过键值查找特定的数值并返回。
  • clear()：将这个字典中的所有元素全部删除。
  • size()：返回字典所包含元素的数量。与数组的length属性类似。
  • keys()：将字典所包含的所有键名以数组形式返回。 values()：将字典所包含的所有数值以数组形式返回。

其他数据结构可访问以下地址：

数据结构与算法（一）之数组，队列，栈（偏向JS）
数据结构与算法（二）之单向链表和双向链表（偏向JS）