基于javaScript的数据结构之集合

集合

集合，是一组无序且唯一的数据集。在计算机的数据结构中，集合，处理是有限的之外，其概念与数学中的概念基本是一样的。
目前ES6语法中，有个Set类，与本篇要实现的集合的功能是一致的，但是，本篇处理实现Set类中的方法之外，扩展了集合的基本运算：交集、差集、并集、是否子集。代码如下：

function CustomSet() {
   this.items = {};
   // 添加元素
   CustomSet.prototype.add = function (ele) {
      if (!this.has(ele)) {
         let key = ele;
         if (typeof ele == "object") {
            key = JSON.stringify(ele)
         }
         this.items[key] = true;
         return true
      }
      return false
   }
   // 是否包含指定元素
   CustomSet.prototype.has = function (ele) {
      let key = ele;
      if (typeof ele == "object") {
         key = JSON.stringify(ele)
      }
      return Object.prototype.hasOwnProperty.call(this.items, key)
   }
   // 删除指定元素
   CustomSet.prototype.delete = function (ele) {
      if (this.has(ele)) {
         let key = ele;
         if (typeof ele == "object") {
            key = JSON.stringify(ele)
         }
         return delete this.items[key];
      }
      return undefined;
   }
   // 清空集合
   CustomSet.prototype.clear = function () {
      this.items = {};
   }
   // 获取集合大小
   CustomSet.prototype.size = function () {
      return Object.keys(this.items).length;
   }
   // 获取集合所有的值
   CustomSet.prototype.values = function () {
      return Object.keys(this.items).join(",")
   }
   // 并集
   CustomSet.prototype.union = function (otherSet) {
      let unionSet = this.copy();
      Object.keys(otherSet.items).forEach(item => {
         if (!unionSet.has(item)) {
            unionSet.add(item);
         }
      })
      return unionSet
   }
   // 交集
   CustomSet.prototype.intersection = function (otherSet) {
      let smallSet = this.size() > otherSet.size() ? otherSet : this;
      let bigSet = smallSet == this ? otherSet : this;
      let intersectionSet = new CustomSet();
      Object.keys(smallSet.items).forEach(item => {
         if (bigSet.has(item)) {
            intersectionSet.add(item);
         }
      })
      return intersectionSet
   }
   // 差集
   CustomSet.prototype.difference = function (otherSet) {
      let differenceSet = new CustomSet();
      Object.keys(this.items).forEach(item => {
         if (!otherSet.has(item)) {
            differenceSet.add(item);
         }
      })
      return differenceSet
   }
   // 子集
   CustomSet.prototype.isSubOf = function (otherSet) {
      if (otherSet.size() > this.size()) return false;
      let kesArr = Object.keys(otherSet.items);
      for (let i = 0; i < kesArr.length; i++) {
         if (!this.has(kesArr[i])) {
            return false
         }
      }
      return true
   }
   // copy当前集合
   CustomSet.prototype.copy = function (set = this) {
      let copySet = new CustomSet()
      Object.keys(this.items).forEach(item => {
         copySet.add(item);
      })
      return copySet
   }
}

let set = new CustomSet();
let set1 = new CustomSet();
set.add({ id: 1 })
set.add({ id: 3 })
set1.add({ id: 1 })
set1.add({ id: 4 })
let isSubOfSet = set.isSubOf(set1)
console.log(isSubOfSet)

从代码的集合类中，可以看到，它是用对象来实现集合的，当然也可以使用JavaScript中的数组来进行封装集合类。在封装集合类中，添加元素的键时，简单使用JSON.stringify()方法进行了类型判断，因为在集合中，不要求存储的数据类型，对象作为键，也可以Symbol，这样也保证了对象的键唯一性。