javascript 集合(set)算法与说明

集合的介绍

集合是由一组无序且唯一（即不能重复）的项组成的。这个和数学的概念很相同有交集、并集和差集等。

增删改查的算法：

let set = new Set();

set.add(1);
set.values(); // [1]
set.has(1);//true
set.size();//1

set.add(2);
set.values(); //[1, 2]

set.delete(1);
set.values(); //[2]

set.delete(2);
set.values(); //[]

set类在本文最底部。

---

并集

若A和B是集合，则A和B并集是有所有A的元素和所有B的元素，而没有其他元素的集合。A和B的并集通常写作 “A∪B”，读作“A并B”，用符号语言表示，即：A∪B={x|x∈A,或x∈B}



并集的方法实现：

function union(otherSet){
        let unionSet = new Set(); 

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

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

        return unionSet;
};

并集的用法：

let setA = new Set();
setA.add(1);
setA.add(2);
setA.add(3);

let setB = new Set();
setB.add(3);
setB.add(4);
setB.add(5);
setB.add(6);

let unionAB = setA.union(setB);

---

交集

设A，B是两个集合，由所有属于集合A且属于集合B的元素所组成的集合，叫做集合A与集合B的交集（intersection）。即：A∩B= {x|x∈A∧x∈B}。



交集的方法实现：

function intersection(otherSet){
     let intersectionSet = new Set(); 

     let values = this.values();
     for (let i=0; i<values.length; i++){ 
         if (otherSet.has(values[i])){    
             intersectionSet.add(values[i]); 
         }
     }

     return intersectionSet;
 };

交集的用法：

let setA = new Set();
setA.add(1);
setA.add(2);
setA.add(3);

let setB = new Set();
setB.add(3);
setB.add(4);
setB.add(5);
setB.add(6);

let unionAB = setA.union(setB);

---

差集

一般地，记A，B是两个集合，则所有属于A且不属于B的元素构成的集合，叫做集合A减集合B（或集合A与集合B之差），类似地，对于集合A、B，我们把集合{x∣x∈A,且x∉B}叫做A与B的差集，



差集的方法实现：

function difference(otherSet){
    let differenceSet = new Set(); 

    let values = this.values();
    for (let i=0; i<values.length; i++){ 
        if (!otherSet.has(values[i])){    
            differenceSet.add(values[i]); 
        }
    }

    return differenceSet;
};

差集的用法：

let setA = new Set();
setA.add(1);
setA.add(2);
setA.add(3);

let setB = new Set();
setB.add(2);
setB.add(3);
setB.add(4);

let differenceAB = setA.difference(setB);

---

子集

子集是一个数学概念：如果集合A的任意一个元素都是集合B的元素，那么集合A称为集合B的子集。
符号语言：若∀a∈A，均有a∈B，则A⊆B



子集的方法实现：

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

子集的用法：

let setA = new Set();
setA.add(1);
setA.add(2);

let setB = new Set();
setB.add(1);
setB.add(2);
setB.add(3);

let subsetAB =setA.subset(setB);

---

ES6集合完整实现代码：

let Set = (function () {

    const items = new WeakMap();

    class Set {

        constructor () {
            items.set(this, {});
        }

        add(value){//向集合添加一个新的项
            if (!this.has(value)){
                let items_ = items.get(this);
                items_[value] = value;
                return true;
            }
            return false;
        }

        delete(value){//删除集合一个特定项
            if (this.has(value)){
                let items_ = items.get(this);
                delete items_[value];
                return true;
            }
            return false;
        }

        has(value){//查找集合中的值，有返回true，没有返回false。
            let items_ = items.get(this);
            return items_.hasOwnProperty(value);
        }

        clear(){//移除集合中所有的项
            items.set(this, {});
        }

        size(){//返回集合所包含元素的数量。
            let items_ = items.get(this);
            return Object.keys(items_).length;
        }


        values(){//返回一个包含集合中所有的值的数组。
            let values = [];
            let items_ = items.get(this);
            for (let i=0, keys=Object.keys(items_); i<keys.length; i++) {
                values.push(items_[keys[i]]);
            }
            return values;
        }

        getItems(){//返回集合
            return items.get(this);
        }

        union(otherSet){//并集，返回一个集合
            let unionSet = new Set();

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

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

            return unionSet;
        }

        intersection(otherSet){//交集，返回一个集合
            let intersectionSet = new Set();

            let values = this.values();
            for (let i=0; i<values.length; i++){
                if (otherSet.has(values[i])){
                    intersectionSet.add(values[i]);
                }
            }

            return intersectionSet;
        }

        difference(otherSet){//差集，返回一个集合
            let differenceSet = new Set();

            let values = this.values();
            for (let i=0; i<values.length; i++){
                if (!otherSet.has(values[i])){
                    differenceSet.add(values[i]);
                }
            }

            return differenceSet;
        };

        subset(otherSet){//子集，返回一个集合

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