集合(Set)：是一种包含不同元素的数据结构。
重要特性：1.集合中的成员时无序的；2.集合中不允许相同的成员存在。
使用场景：用于存储一些独一无二的元素。
1 集合的定义：（和高中数学中的集合一样）是有一组无序且彼此之间又有一定相关性的成员构成，每个成员只能出现一次。
1.1基本概念：
空集：不包含任何成员的集合。
全集：包含一切可能成员的集合。
两个集合相等：两个集合的成员完全相等。
子集：一个集合中的所有成员都属于另外一个集合，前一个集合是后一个集合的子集。
1.2 集合的基本操作：
并集：将两个集合的成员进行合并
交集：两个集合中共同存在的成员
补集：属于一个集合而不属于另一个集合的成员
2.Set类的实现：
Set类的实现基于数组存储。
function Set() {
this.dataStore = [];
/*this.add = add;
this.remove = remove;
this.size = size;
this.show = show;
this.union = union;(并集)
this.contains = contains;
this.intersect = intersect;(交集)
this.subset = subset;
this.difference = difference;*/
}
向集合中添加成员
Set.prototype.add = function(data) {
if(this.dataStore.indexOf(data) <0) {//判断集合是否存在所添加的成员，indexOf检索数据如果找到成员返回该成员在数组中的位置，没找到返回-1。
this.dataStore.push(data);
return true;
}else{
return false;
}
};
从集合中删除成员
Set.prototype.remove = function(data) {
var _pos = this.dataStore.indexOf(data);//检索该成员是否存在
if(_pos > -1) {//该成员存在
this.dataStore.splice(_pos,1);
return true;
}else{
return false;
}
};
显示该集合的成员信息
Set.prototype.show = function() {
return this.dataStore;
};
显示该集合的成员个数
Set.prototype.size = function() {
return this.dataStore.length;
};
//跑起来。。。
var set1 = new Set();
set1.add("Seafuwg");
set1.add("Wunworld");
set1.add("Assassin");
console.log(set1.show());
console.log(set1.size());
2、集合的高级操作：交intersect()、并union()、差（补）difference()、子集subset();
union()方法执行并集操作，将两个集合合并成一个集合。
该方法首先将第一个集合的成员悉数加入一个临时集合，然后检查第二个集合的成员，看他们是否也同时属于第一个集合，如果存在，则跳过该成员，否则就将该成员加入临时集合。
并集操作，在并集定义时首先定义一个辅助方法contains(),该方法检测一个成员是否属于该集合
Set.prototype.contains = function(data) {
if(this.dataStore.indexOf(data) > -1) {
return true;
}else{
return false;
}
};
并集操作
Set.prototype.union = function(set) {
var _tempSet = new Set();//临时集合
for(var i = 0;i < this.dataStore.length;i++) {
_tempSet.add(this.dataStore[i]);//添加到临时集合中
}
for(var i = 0; i < set.dataStore.length;i++) {//遍历集合
if(!_tempSet.contains(set.dataStore[i])) {//检测成员是否属于该集合
_tempSet.dataStore.push(set.dataStore[i]);//不属于该集合的成员添加到临时集合中
}
}
return _tempSet;
};
赶快跑一把。。
var set2 = new Set();
set2.add("2222");
set2.add("wunworld");
set2.add("Wunworld");
set2.add("Assassin");
var newSet = new Set();
newSet = set2.union(set1);
console.log(newSet);
交集intersect();的实现：
每当发现第一个集合的成员也属于第二个集合时。便将该成员加入一个新的集合。
Set.prototype.intersect = function(set) {
var _tempSet = new Set();
for(var i = 0;i < this.dataStore.length;i++) {//遍历集合
if(set.contains(this.dataStore[i])) {//判断是否有相同的成员
_tempSet.add(this.dataStore[i]);//相同的添加到临时集合中
}
}
return _tempSet;
};
at once running...
var newSet2 = new Set();
newSet2 = set1.intersect(set2);
console.log(newSet2);
补集difference();的实现:
该方法返回一个新的集合，该集合包含的是属于第一个集合但不属于第二个集合的成员。
Set.prototype.difference= function(set) {
var _tempSet = new Set();
for(var i = 0;i < this.dataStore.length;i++) {
if(!set.contains(this.dataStore[i])) {
_tempSet.add(this.dataStore[i]);
}
}
return _tempSet;
};
//Running...
var set3 = new Set();
var set4 = new Set();
set3.add("Wunworld");
set3.add("Assassin");
set3.add("Seafuwg");
set4.add("Seafuwg");
set4.add("Assassin");
set4.add("2112313");
var diff = new Set();
diff = set3.difference(set4);
console.log(diff);
// Wunworld
子集subset();的实现：
该方法首先要确定该集合的长度要小于要比较的集合的长度。再判断该集合内的成员是否都属于待比较集合。如果有任意一个成员不属于待比较集合，返回false。如果一直比较完该集合的最后一个元素都属于待比较集合，则该集合就是待比较集合的一个子集，返回true。
Set.prototype.subset = function(set) {
/*if(this.size() > set.size()) {
return false;
}else{
for(var member in this.dataStore) {
if(!set.contains(member)) {
return false;
}
}
return true;
}*/
if(this.size() > set.size()) {
return false;
}else{
return this.dataStore.every(function (item) {
//every() 方法用于检测数组所有元素是否都符合指定条件（通过函数提供)
//如果数组中检测到有一个元素不满足，则整个表达式返回 false ，且剩余的元素不会再进行检测。
//如果所有元素都满足条件，则返回 true。
return set.dataStore.indexOf(item)>-1
});
}
};
//running..
var set5 = new Set();
set5.add("Assassin");
console.log(set5.subset(set4));
//true...
=====================================
完整实现：
function Set() {
this.dataStore = [];
/*this.add = add;
this.remove = remove;
this.size = size;
this.show = show;
this.union = union;(并集)
this.contains = contains;
this.intersect = intersect;(交集)
this.subset = subset;
this.difference = difference;*/
}
Set.prototype = {
add : function(data) {
if(this.dataStore.indexOf(data) <0) {//判断集合是否存在所添加的成员，indexOf检索数据如果找到成员返回该成员在数组中的位置，没找到返回-1。
this.dataStore.push(data);
return true;
}else{
return false;
}
},
remove:function(data) {
var _pos = this.dataStore.indexOf(data);//检索该成员是否存在
if(_pos > -1) {//该成员存在
this.dataStore.splice(_pos,1);
return true;
}else{
return false;
}
},
show:function() {
return this.dataStore;
},
size:function() {
return this.dataStore.length;
},
contains:function(data) {
if(this.dataStore.indexOf(data) > -1) {
return true;
}else{
return false;
}
},
union:function(set) {
var _tempSet = new Set();//临时集合
for(var i = 0;i < this.dataStore.length;i++) {
_tempSet.add(this.dataStore[i]);//添加到临时集合中
}
for(var i = 0; i < set.dataStore.length;i++) {//遍历集合
if(!_tempSet.contains(set.dataStore[i])) {//检测成员是否属于该集合
_tempSet.dataStore.push(set.dataStore[i]);//不属于该集合的成员添加到临时集合中
}
}
return _tempSet;
},
intersect:function(set) {
var _tempSet = new Set();
for(var i = 0;i < this.dataStore.length;i++) {//遍历集合
if(set.contains(this.dataStore[i])) {//判断是否有相同的成员
_tempSet.add(this.dataStore[i]);//相同的添加到临时集合中
}
}
return _tempSet;
},
difference:function(set) {
var _tempSet = new Set();
for(var i = 0;i < this.dataStore.length;i++) {
if(!set.contains(this.dataStore[i])) {
_tempSet.add(this.dataStore[i]);
}
}
return _tempSet;
}
};
