javascript数据结构与算法（笔记）---集合、交集、并集、子集

<script>
    //以Set类的骨架
    /*
    * add(value) 向集合添加一个新的项
    * remove(value) 从集合移除一个值
    * has(value) 如果值在集合中，返回true，否则返回false
    * clear() 移除集合中所有的项
    * size() 返回集合所包含元素的数量
    //size方法的实现有三种形式:1、使用length变量，在add和remove的时候，控制它，2、Object.keys(items).length;
    //Object类的keys方法，返回一个包含指定对象所有属性的数组，目前该方法有浏览器的兼容性
    * values() 返回一个包含集合所有值的数组
    */
    function Set() {
      var items = {};

      this.has = function(value) {
        return value in items; // 也可以这样实现：return items.hasOwnProperty(value)
      }

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

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

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

      this.size = function() {
        var count = 0;
        for(var prop in items) {
          if(items.hasOwnProperty(prop)) {
            ++count;
          }
        }
        return count;
        // 不能简单地使用for-in语句遍历items对象的属性，递增count变量的值。还需要使用has方法验证items对象具有该属性
        // 因为对象的原型包含了额外的属性（既有对象自身的，也有Object类的）
      }

      this.values = function() {
        // 可以return Object.keys(items);
        var keys = [];
        for(var key in items) {
          keys.push(key);
        }
        return keys;
      }

      this.union = function(otherSet) { //并集
        var unionSet = new Set();
        var values = this.values();
        for(var i = 0; i < values.length; i++) {
          unionSet.add(values[i]);
        }

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

      this.intersection = function(otherSet) { //交集
        var intersectionSet = new Set();
        var values = this.values();
        for(var i = 0; i < values.length; i++) {
          if(otherSet.has(values[i])) {
            intersectionSet.add(values[i]);
          }
        }
        return intersectionSet;
      }

      this.difference = function() { // 差集
        var differenceSet = new Set();
        var values = this.values();
        for(var i = 0; i < values.length; i++) {
          if(!otherSet.has(values[i])) {
            differenceSet.add(values[i]);
          }
        }
        return differenceSet;
      }

      this.subset = function(otherSet) { //子集
        if(this.size() > otherSet.size()) {
          return false;
        }else {
          var values = this.values();
          for(var i = 0; i < values.length; i++) {
            if(!otherSet.has(values[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 setAB = setA.union(setB);
    console.log(setAB.values());
  </script>