JavaScript数据结构与算法(八) 集合（ECMAScript 6中定义的类似的Set类）

TypeScript方式实现源码

// 特性：
// 1. 集合是由一组无序且唯一（即不能重复）的项组成的。这个数据结构使用了与有限集合相同的数学概念，但应用在计算机科学的数据结构中。 
// 2. 也可以把集合想象成一个既没有重复元素，也没有顺序概念的数组
// 3. 在数学中，集合也有并集、交集、差集等基本操作。在这一章中我们也会介绍这些操作

// 集合操作
// 并集：对于给定的两个集合，返回一个包含两个集合中所有元素的新集合
// 并集的数学概念，集合A和B的并集，表示为A∪B，定义如下： 
// A∪B = { x | x ∈ A∨x ∈ B } 
// 意思是x（元素）存在于A中，或x存在于B中。下图展示了并集操作： 
// 并集.png

// 交集：对于给定的两个集合，返回一个包含两个集合中共有元素的新集合
// 交集的数学概念，集合A和B的交集，表示为A∩B，定义如下： 
// A∩B = { x | x ∈ A∧x ∈ B } 
// 意思是x（元素）存在于A中，且x存在于B中。下图展示了交集操作： 
// 交集.png

// 差集：对于给定的两个集合，返回一个包含所有存在与第一个集合且不存在与第二个集合的元素的新集合
// 差集的数学概念，集合A和B的差集，表示为AB，定义如下： 
// AB = { x | x ∈ A ∧ x B } 
// 意思是x（元素）存在于A中，且x不存在于B中。下图展示了集合A和B的差集操作： 
// 差集.png

// 子集：验证一个给定集合是否是另一个集合的子集
// 最后一个集合操作是子集。子集的数学概念，集合A是B的子集（或集合B包含
// 了A） ，表示为A⊆B，定义如下： 
// ∀x { x ∈ A → x ∈ B } 
// 意思是集合A中的每一个x（元素） ，也需要存在于B中。下图展示了集合A是集合B的子集： 
// 子集.png

class Set {
    private items: Object = {};
    /**
     * 向集合添加一个新的项
     * @param value 
     */
    public add(value) {
        if (!this.has(value)) {
            this.items[value] = value;
            return true;
        }
    }
    /**
     * 从集合移除一个值
     * @param value 
     */
    public remove(value) {
        if (this.has(value)) {
            delete this.items[value];
            return true;
        }
        return false;
    }
    /**
     * 如果值在集合中，返回true，否则返回false
     * @param value 
     */
    public has(value) {
        return this.items.hasOwnProperty(value);
    }
    /**
     * 移除集合中的所有项
     */
    public clear() {
        this.items = {};
    }
    /**
     * 返回集合所包含元素的数量。与数组的length属性类似
     */
    public size() {
        var count = 0;
        for (var prop in this.items) { //{5} 
            if (this.items.hasOwnProperty(prop)) //{6} 
                ++count; //{7} 
        }
        return count;
    }
    /**
     * 返回一个包含集合中所有值的数组
     */
    public values() {
        var keys = [];
        for (var key in this.items) { //{7} 
            keys.push(key); //{8} 
        }
        return keys;
    }
    public union(otherSet: Set): Set {
        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;
    }
    public intersection(otherSet: Set) {
        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;
    }
    public difference(otherSet: Set) {
        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;
    }
    public subset(otherSet: Set) {
        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;
        }
    }

}

// 使用 Set 类
let set = new Set();

set.add(1);
console.log(set.values()); //输出["1"] 
console.log(set.has(1)); //输出true 
console.log(set.size()); //输出1 

set.add(2);
console.log(set.values()); //输出["1", "2"] 
console.log(set.has(2)); //true 
console.log(set.size()); //2 

set.remove(1);
console.log(set.values()); //输出["2"] 

set.remove(2);
console.log(set.values()); //输出[] 

// 测试一下并集的代码：
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());
//输出为["2", "3"]，因为2和3同时存在于两个集合中

// 测试一下差集的代码
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());
//输出为["1"]，因为1是唯一一个仅存在于setA的元素。

// 测试一下子集的代码
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.subset(setB));
console.log(setA.subset(setC));
// 我们有三个集合：setA是setB的子集 （因此输出为true） ， 然而setA不是setC的子集 （setC
// 只包含了setA中的2，而不包含1） ，因此输出为false

总结：我们将从头实现一个与ECMAScript 6中定义的类似的Set类。我们还介绍了在其他编程语言的集合数据结构的实现中不常见的一些方法，比如并集、交集、差集和子集。因此，相比于其他编程语言目前的Set实现，我们实现了一个非常完备的Set类

JavaScript方式实现源码

var Set = (function () {
    function Set() {
        this.items = {};
    }
    /**
     * 向集合添加一个新的项
     * @param value
     */
    Set.prototype.add = function (value) {
        if (!this.has(value)) {
            this.items[value] = value;
            return true;
        }
    };
    /**
     * 从集合移除一个值
     * @param value
     */
    Set.prototype.remove = function (value) {
        if (this.has(value)) {
            delete this.items[value];
            return true;
        }
        return false;
    };
    /**
     * 如果值在集合中，返回true，否则返回false
     * @param value
     */
    Set.prototype.has = function (value) {
        return this.items.hasOwnProperty(value);
    };
    /**
     * 移除集合中的所有项
     */
    Set.prototype.clear = function () {
        this.items = {};
    };
    /**
     * 返回集合所包含元素的数量。与数组的length属性类似
     */
    Set.prototype.size = function () {
        var count = 0;
        for (var prop in this.items) {
            if (this.items.hasOwnProperty(prop))
                ++count; //{7} 
        }
        return count;
    };
    /**
     * 返回一个包含集合中所有值的数组
     */
    Set.prototype.values = function () {
        var keys = [];
        for (var key in this.items) {
            keys.push(key); //{8} 
        }
        return keys;
    };
    Set.prototype.union = function (otherSet) {
        var unionSet = new Set();
        var values = this.values();
        for (var i_1 = 0; i_1 < values.length; i_1++) {
            unionSet.add(values[i_1]);
        }
        values = otherSet.values();
        for (var i_2 = 0; i_2 < values.length; i_2++) {
            unionSet.add(values[i_2]);
        }
        return unionSet;
    };
    Set.prototype.intersection = function (otherSet) {
        var intersectionSet = new Set();
        var values = this.values();
        for (var i_3 = 0; i_3 < values.length; i_3++) {
            if (otherSet.has(values[i_3])) {
                intersectionSet.add(values[i_3]);
            }
        }
        return intersectionSet;
    };
    Set.prototype.difference = function (otherSet) {
        var differenceSet = new Set();
        var values = this.values();
        for (var i_4 = 0; i_4 < values.length; i_4++) {
            if (!otherSet.has(values[i_4])) {
                differenceSet.add(values[i_4]);
            }
        }
        return differenceSet;
    };
    Set.prototype.subset = function (otherSet) {
        if (this.size() > otherSet.size()) {
            return false;
        }
        else {
            var values = this.values();
            for (var i_5 = 0; i_5 < values.length; i_5++) {
                if (!otherSet.has(values[i_5])) {
                    return false;
                }
            }
            return true;
        }
    };
    return Set;
}());