概念

  • 集合是由一组无序且唯一（即不能重复）的项组成的
  • 该数据结构使用了与有限集合相同的数学概念，但应用在计算机科学的数据结构中
  • 集合的存储是值 和 值对应

集合方法

  • add(element)：向集合添加一个新元素。
  • delete(element)：从集合移除一个元素。
  • has(element)：如果元素在集合中，返回true，否则返回false。
  • clear()：移除集合中的所有元素。
  • size()：返回集合所包含元素的数量。它与数组的length 属性类似。
  • values()：返回一个包含集合中所有值（元素）的数组。

实现

构造存储结构：对象{value: value} 值 和 值

  1. class set {
  2.     constructor() {
  3.         this.items = {};
  4.     }
  5. }

判断元素唯一性的方法

  1. has(ele) {
  2.     return Object.prototype.hasOwnProperty.call(this.items, ele);
  3. }

各种方法的实现

  1.     add(ele) {
  2.         if (!this.has(ele)) {
  3.             this.items[ele] = ele;
  4.             return true;
  5.         }
  6.         return false;
  7.     }
  9.     delete(ele) {
  10.         if (this.has(ele)) {
  11.             delete this.items[ele];
  12.             return true;
  13.         }
  14.         return false;
  15.     }
  16.     clear() {
  17.         this.items = {};
  18.     }
  19.     size() {
  20.         // return Object.keys(this.items).length    // es6写法
  21.         let cnt = 0;
  22.         for (let key in this.items) {
  23.             if (this.has(key)) {
  24.                 cnt++;
  25.             }
  26.         }
  27.         return cnt;
  28.     }
  29.     values() {
  30.         let values = [];
  31.         for (let key in this.items) {
  32.             if (this.has(key)) {
  33.                 values.push(this.items[key]);
  34.             }
  35.         }
  36.         return values;
  37.     }

交集，并集，差集，子集

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

并集运算

  1.     union(otherSet) {
  2.         let unionSet = new MySet();   // 存储最终的并集集合数据
  3.         this.values().forEach(value => {
  4.             unionSet.add(value);
  5.         });
  6.         otherSet.values().forEach(value => {
  7.             unionSet.add(value);
  8.         });
  9.         return unionSet;
  10.     }

交集运算

  1.     intersection(otherSet) {
  2.         let intersection = new MySet();
  3.         let values = this.values(); // 预存当前集合值数组
  4.         // 判断哪个大哪个小
  5.         let otherValues = otherSet.values();
  6.         let bigSet = undefined;
  7.         let smallSet = undefined;
  8.         if (values.length > otherValues.length) {
  9.             bigSet = values;
  10.             smallSet = otherValues;
  11.         } else {
  12.             bigSet = otherValues;
  13.             smallSet = values;
  14.         }
  15.         for (let i = 0; i < smallSet.length; i++) {
  16.             // 直接判断可能导致性能损耗，应该判断小的那个集合
  17.             if (bigSet.has(smallSet[i])) {
  18.                 intersection.add(smallSet[i]);
  19.             }
  20.         }
  21.     }

差集运算

集合 - 图1

  1.     difference(otherSet) {
  2.         // 需要深拷贝
  3.         let differenceSet = this;
  4.         let intersection = this.intersection(otherSet);
  5.         // 删除交集元素
  6.         intersection.values().forEach(value => {
  7.             differenceSet.delete(value);
  8.         });
  9.         return differenceSet;
  10.     }

子集运算

集合 - 图2

  1.     isSubsetOf(otherSet) {
  2.         if (this.size() > otherSet.size()) {
  3.             return false;
  4.         }
  5.         let isSubset = true;
  6.         this.values().every(value => {
  7.             if (!otherSet.has(value)) {
  8.                 isSubset = false;
  9.                 return false;
  10.             }
  11.             return true;
  12.         });
  13.         return isSubset;
  14.     }

完整代码

  1. class MySet {
  2.     constructor() {
  3.         this.items = {};
  4.     }
  5.     // 判断元素的唯一性
  6.     has(ele) {
  7.         return Object.prototype.hasOwnProperty.call(this.items, ele);
  8.     }
  10.     add(ele) {
  11.         if (!this.has(ele)) {
  12.             this.items[ele] = ele;
  13.             return true;
  14.         }
  15.         return false;
  16.     }
  18.     delete(ele) {
  19.         if (this.has(ele)) {
  20.             delete this.items[ele];
  21.             return true;
  22.         }
  23.         return false;
  24.     }
  25.     clear() {
  26.         this.items = {};
  27.     }
  28.     size() {
  29.         // return Object.keys(this.items).length    // es6写法
  30.         let cnt = 0;
  31.         for (let key in this.items) {
  32.             if (this.has(key)) {
  33.                 cnt++;
  34.             }
  35.         }
  36.         return cnt;
  37.     }
  38.     values() {
  39.         let values = [];
  40.         for (let key in this.items) {
  41.             if (this.has(key)) {
  42.                 values.push(this.items[key]);
  43.             }
  44.         }
  45.         return values;
  46.     }
  48.     union(otherSet) {
  49.         let unionSet = new MySet();   // 存储最终的并集集合数据
  50.         this.values().forEach(value => {
  51.             unionSet.add(value);
  52.         });
  53.         otherSet.values().forEach(value => {
  54.             unionSet.add(value);
  55.         });
  56.         return unionSet;
  57.     }
  59.     intersection(otherSet) {
  60.         let intersection = new MySet();
  61.         let values = this.values(); // 预存当前集合值数组
  62.         // 判断哪个大哪个小
  63.         let otherValues = otherSet.values();
  64.         let bigSet = undefined;
  65.         let smallSet = undefined;
  66.         if (values.length > otherValues.length) {
  67.             bigSet = values;
  68.             smallSet = otherValues;
  69.         } else {
  70.             bigSet = otherValues;
  71.             smallSet = values;
  72.         }
  73.         for (let i = 0; i < smallSet.length; i++) {
  74.             // 直接判断可能导致性能损耗，应该判断小的那个集合
  75.             if (bigSet.has(smallSet[i])) {
  76.                 intersection.add(smallSet[i]);
  77.             }
  78.         }
  79.     }
  81.     difference(otherSet) {
  82.         // 需要深拷贝
  83.         let differenceSet = this;
  84.         let intersection = this.intersection(otherSet);
  85.         // 删除交集元素
  86.         intersection.values().forEach(value => {
  87.             differenceSet.delete(value);
  88.         });
  89.         return differenceSet;
  90.     }
  92.     isSubsetOf(otherSet) {
  93.         if (this.size() > otherSet.size()) {
  94.             return false;
  95.         }
  96.         let isSubset = true;
  97.         this.values().every(value => {
  98.             if (!otherSet.has(value)) {
  99.                 isSubset = false;
  100.                 return false;
  101.             }
  102.             return true;
  103.         });
  104.         return isSubset;
  105.     }
  106. }