数据结构与算法--集合（Set）--JS

Posted 2021-11-21 煜成'Studio

数据结构与算法–集合（Set）–JS

集合比较常用的实现方式是哈希表，这里来实现一个封装的集合类
集合通常是一组无序的、不能重复的元素构成

//封装集合类
function Set() {
    //属性
    this.items = {};
    //方法
    //add方法
    Set.prototype.add = function (value) {
        //判断当前集合中是否已经包含了该元素
        if (this.has(value)) {
            return false;
        }
        //将元素添加到集合中
        this.items[value] = value;
        return true;
    }

    //has方法
    Set.prototype.has = function (value) {
        return this.items.hasOwnProperty(value);
    }

    //remove方法
    Set.prototype.remove = function (value) {
        //判断该集合是否包含该元素
        if (!this.has(value)) {
            return false;
        }
        //将元素从属性中删除
        delete this.items[value];
        return true;
    }

    //clear方法
    Set.prototype.clear = function () {
        this.items = {};
    }

    //size方法
    //下面两个方法也需要考虑兼容性问题
    Set.prototype.size = function () {
        return Object.keys(this.items).length;
    }

    //获取集合中所有的值
    Set.prototype.values = function () {
        return Object.keys(this.items);
    }

    //集合间的操作
    //并集
    Set.prototype.union = function (otherSet) {
        //this: 集合对象A
        //otherSet: 集合对象B
        //创建新的集合
        var unionSet = new Set();
        //将A集合中所有的元素添加到新集合中
        var values = this.values();
        for (var i = 0; i < values.length; i++) {
            unionSet.add(values[i]);
        }
        //取出B集合中的元素，判断是否需要加到新集合
        values = otherSet.values();
        for (var i = 0; i < values.length; i++) {
            unionSet.add(values[i]);
        }
        return unionSet;
    }

    //交集
    Set.prototype.intersection = function (otherSet) {
        //this:集合A
        //otherSet:集合B
        //创建新的集合
        var intersectionSet = new Set();
        var values = this.values();
        //判断
        for (var i = 0; i < values.length; i++) {
            var item = values[i];
            if (otherSet.has(item)) {
                intersectionSet.add(item);
            }
        }
        return intersectionSet;
    }

    //差集
    Set.prototype.difference = function (otherSet) {
        //this：集合A
        //otherSet：集合B
        //创建新的集合
        var difference = new Set();
        //判断
        var values = this.values();
        for (var i = 0; i < values.length; i++) {
            var item = values[i];
            if (!otherSet.has(item)) {
                difference.add(item);
            }
        }
        return difference;
    }

    //子集
    Set.prototype.subset = function (otherSet) {
        //this:集合A
        //otherSet:集合B
        var values = this.values();
        for (var i = 0; i < values.length; i++) {
            var item = values[i];
            if (!otherSet.has(item)) {
                return false;
            }
        }
        return true;
    }
}

// //测试Set类
// var set = new Set();
// //添加元素
// alert(set.add('abc'));
// alert(set.add('cba'));
// alert(set.add('abc'));
// //查看元素
// alert(set.values());
// //删除元素
// alert(set.remove('abc'));
// alert(set.remove('abc'));
// alert(set.values());
// //has方法
// alert(set.has('cba'));
// //获取元素的个数
// alert(set.size());
// set.clear();
// alert(set.size());

//集合间操作测试
//创建两个集合，并添加元素
var setA = new Set();
setA.add('abc');
setA.add('cba');
setA.add('nba');
var setB = new Set();
setB.add('aaa');
setB.add('nba');
setB.add('cba');
//求两个集合的并集
// var unionSet = setA.union(setB);
// alert(unionSet.values());

// //求两个集合的交集
// var intersectionSet = setA.intersection(setB);
// alert(intersectionSet.values());

//求差集
// var differenceSet = setA.difference(setB);
// alert(differenceSet.values());
//判断子集
alert(setA.subset(setB));