js-数据结构和算法-集合

集合

集合是由一组无序且唯一（即不能重复）的项组成的
集合是一个既没有重复元素，也没有顺序概念的数组。

声明一些集合可用的方法（我们会尝试模拟与ECMAScript 6实现相同的Set类）。

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

集合的操作

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

并集的数学概念，集合A和B的并集，表示为A∪B，定义如下：
A∪B = { x | x ∈ A∨x ∈ B }
意思是x（元素）存在于A中，或x存在于B中

交集的数学概念，集合A和B的交集，表示为A∩B，定义如下：
A∩B = { x | x ∈ A∧x ∈ B }
意思是x（元素）存在于A中，且x存在于B中。

差集的数学概念，集合A和B的差集，表示为AB，定义如下：
AB = { x | x ∈ A ∧ x B }
意思是x（元素）存在于A中，且x不存在于B中

子集的数学概念，集合A是B的子集（或集合B包含
了A），表示为A⊆B，定义如下：
∀x { x ∈ A → x ∈ B }
意思是集合A中的每一个x（元素），也需要存在于B中

function Set() {
  let items = {}
  this.add = function(v) {
    if(!this.has(v)) {
      items[v] = v
      return true
    }
    return false
  }
  this.remove = function(v) {
    if(!this.has(v)) {
      delete items[v]
      return true
    }
    return false
  }
  this.has = function(v) {
    return items.hasOwnProperty(v)
  }
  this.clear = function(v) {
    items = {}
  }
  this.size = function(v) {
    return Object.keys(items).length
  }
  this.values = function(v) {
    return Object.values(items)
  }
  // 并集,求和
  this.union = function(set) {
    let unionSet = new Set()
    let itemsValues = this.values()
    for (let i = 0; i < itemsValues.length; i++) {
      unionSet.add(itemsValues[i])
    }
    let setValues = set.values()
    for (let i = 0; i < setValues.length; i++) {
      unionSet.add(setValues[i])
    }
    return unionSet
  }
  // 交集,包含
  this.interSection = function(set) {
    let resSet = new Set()
    let itemsValues = this.values()
    for (let i = 0; i < itemsValues.length; i++) {
      if(set.has(itemsValues[i])) {
        resSet.add(itemsValues[i])
      }
    }
    return resSet
  }
  // 差集，不包含
  this.difference = function(set) {
    let resSet = new Set()
    let itemsValues = this.values()
    for (let i = 0; i < itemsValues.length; i++) {
      if(!set.has(itemsValues[i])) {
        resSet.add(itemsValues[i])
      }
    }
    return resSet
  }
  // 是否是set的子集
  this.isSubSet = function(set) {
    if (set.size < this.size ) {
      return false
    }
    let itemsValues = this.values()
    for (let i = 0; i < itemsValues.length; i++) {
      if(!set.has(itemsValues[i])) {
        return false
      }
    }
    return true
  }
}
// var setA = new Set();
// setA.add(1);
// setA.add(2);
// setA.add(3);
// var setB = new Set();
// setB.add(3);
// setB.add(4);
// setB.add(5);
// setB.add(6);
// var unionAB = setA.union(setB);
// console.log(unionAB.values());

// var setA = new Set();
// setA.add(1);
// setA.add(2);
// setA.add(3);
// var setB = new Set();
// setB.add(2);
// setB.add(3);
// setB.add(4);
// var intersectionAB = setA.interSection(setB);
// console.log(intersectionAB.values());

// var setA = new Set();
// setA.add(1);
// setA.add(2);
// setA.add(3);
// var setB = new Set();
// setB.add(2);
// setB.add(3);
// setB.add(4);
// var differenceAB = setA.difference(setB);
// console.log(differenceAB.values());

var setA = new Set();
setA.add(1);
setA.add(2);
var setB = new Set();
setB.add(1);
setB.add(2);
setB.add(3);
var setC = new Set();
setC.add(2);
setC.add(3);
setC.add(4);
console.log(setA.isSubSet(setB));
console.log(setA.isSubSet(setC));