数据结构-javascript实现【集合】

集合是由一组无序且唯一的项组成的。

1.集合的职责方法

add(value): 向集合中添加新的项

remove(value): 从集合中移除一个值

has(value): 检查集合中是否有该值

clear(): 清空集合

size(): 返回集合中项目的个数

values(): 返回集合中所有项的数组

union(otherSet): 返回与另一个集合的并集的集合

intersection(otherSet): 返回与另一个集合的交集的集合

differrence(otherSet): 返回与另一个集合差集的集合

subset(otherSet): 检查是否是另一个集合的子集

2.集合的实现

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;
  }

  union(otherSet) {
    const unionSet = new Set();
    const values = this.values();
    for(let i = 0; i< values.length; i++){
      unionSet.add(values[i]);
    }

    const otherValues = otherSet.values();
    for(let i = 0; i< otherValues.length; i++){
      unionSet.add(otherValues[i]);
    }
    return unionSet;
  }

  intersection(otherSet) {
    const intersectionSet = new Set();
    const values = this.values();
    for(let i =0; i){
      if(otherSet.has(values[i])){
        intersectionSet.add(values[i]);
      }
    }
    return intersectionSet;
  }

  difference(otherSet){
    const differenceSet = new Set();
    const values = this.values();
    for (let i =0; i){
      if(!otherSet.has(values[i])){
        differenceSet.add(values[i]);
      }
    }
    return differenceSet;
  }

  subset(otherSet) {
    if(this.size() > otherSet.size()) return false;
    const values = this.values();
    for (let i = 0; i < values.length; i++){
      if(!otherSet.has(values[i])){
        return false;
      }
    }
    return true;
  }

  clear(){
    this.items = {};
  }

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

  values() {
    return Object.values(this.items);
  }
}

const set = new Set();
set.add(1);
set.add(2);
console.log(set.values());// [1, 2]
console.log(set.has(1)); // true
console.log(set.size()); // 2
set.remove(1);
console.log(set.values()); // [2]

const setA = new Set();
setA.add(1);
setA.add(2);
const setB = new Set();
setB.add(3);
setB.add(4);
const unionAB = setA.union(setB);
console.log(unionAB.values()); // [1,2,3,4]

const setC = new Set();
setC.add(1);
setC.add(2);
const setD = new Set();
setD.add(2);
setD.add(3);
const intersectionCD = setC.intersection(setD);
console.log(intersectionCD.values()); // [2]
const differenceCD = setC.difference(setD);
console.log(differenceCD.values()); // [1]
const setE = new Set();
setE.add(1);
console.log(setE.subset(setC));
console.log(setE.subset(setD));