数据结构与算法--集合（Set）--JS_js set remove

数据结构与算法–集合（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));
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159