数据结构02

1、集合

集合是由一组无序且唯一（不能重复）的项组成的。这个数据结构使用了与有限集合相同的数学概念，但应用在计算机科学的数据结构中。·

在数学中，集合是一组不同的对象（的集）。

比如说：一个由大于或等于0的证书组成的自然数集合：N = { 0, 1, 2, 3, 4, 5, 6, ... }，集合中的对象列表用{}包围。

集合是由一组一（即不能重的项组成的。这个数据结构使用了与有..合相同的数学..，但应用在.算..学的数据结构中。

目前 ES6 中已内置了 Set 类型的实现，出于学习目的，下面我们依旧使用Javascript创建一个集合类：

知识储备：

Object.values()方法返回一个给定对象自身的所有可枚举属性值的数组，

值的顺序与使用for...in循环的顺序相同 ( 区别在于 for-in 循环枚举原型链中的属性 )。

Object.keys 返回一个所有元素为字符串的数组，其元素来自于从给定的object上面可直接

枚举的属性。这些属性的顺序与手动遍历该对象属性时的一致。

 delete 操作符用于删除对象的某个属性；如果没有指向这个属性的引用，那它最终会被释放。

class Set {

    constructor() {
        this.items = {}
    }

    has(value) {
        return this.items.hasOwnProperty(value)
    }

    add(value) {
        if (!this.has(value)) {
            this.items[value] = value
            return true
        }     
        return false
    }

    remove(value) {
        if (this.has(value)) {
            delete this.items[value]
            return true
        }
        return false
    }

    get size() {
        return Object.keys(this.items).length
    }

    get values() {
        return Object.keys(this.items)
    }
}

2）

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

• //求交集
  function cross(set1, set2) {
      if (typeof set1.items !== 'object' || typeof set2.items !== 'object') return {}
      let crossGroup = new Set()
      for (var key in set1.items) {
          if (set2.items[key]) {
              crossGroup.items[key] = set1.items[key]
          }
      }
      return crossGroup
  }
  
  //求并集
  function gather(set1, set2) {
      if (typeof set1.items !== 'object' || typeof set2.items !== 'object') return {}
      let allGroup = new Set()
      for (let key in set1.items) {
          allGroup.items[key] = set1.items[key]
      }
  
      for (let key in set2.items) {
          if (!allGroup.items[key]) {
              allGroup.items[key] = set2.items[key]
          }
      }
      return allGroup
  }
  
  //求差集
  function differens(set1, set2) {
      if (typeof set1.items !== 'object' || typeof set2.items !== 'object') return {}
      let differens1 = new Set()
      let differens2 = new Set()
      let crossGroup = cross(set1, set2).items
      for (let key in set1.items) {
          if (!crossGroup[key]) {
              differens1.add(set1.items[key])
          }
      }
  
      for (let key in set2.items) {
          if (!crossGroup[key]) {
              differens2.add(set2.items[key])
          }
      }
      return [differens1.items, differens2.items]
  }
  
  //判断是否是子集
  function isSon(set1, set2) {
      if (typeof set1.items !== 'object' || typeof set2.items !== 'object') return false
      let crossGroup = cross(set1, set2).items
      let son = set1.size > set2.size ? set2.items : set1.items
  
      for (let key in son) {
          if (!crossGroup[key]) {
              return false
          }
      }
      return true
  }