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