本系列的第一篇文章: 进修JavaScript数据结构与算法（一），栈与行列
第二篇文章：进修JavaScript数据结构与算法（二）：链表
第三篇文章：进修JavaScript数据结构与算法（三）：鸠合
第四篇文章：进修JavaScript数据结构与算法（四）：二叉搜刮树
鸠合(Set)
提及鸠合，就想起刚进高中时，数学第一课讲的就是鸠合。因此在进修鸠合这类数据结构时，倍感亲热。
鸠合的基础性子有一条: 鸠合中元素是不反复的。由于这类性子，所以我们选用了对象来作为鸠合的容器，而非数组。
虽然数组也能做到一切不反复，但究竟过于烦琐，不如鸠合。
鸠合的操纵
鸠合的基础操纵有交集、并集、差集等。这儿我们引见JavaScipt鸠合中交集、并集、差集的完成。至于这三个的详细观点，能够看图:
JavaScipt中鸠合的完成
起首，建立一个组织函数。
/**
* 鸠合的组织函数
*/
function Set() {
/**
* 鸠合元素的容器，以对象来示意
* @type {Object}
*/
var items = {};
}鸠合须要有以下要领:
has(value): 检测鸠合内是不是有某个元素
add(value): 给鸠合内增加某个元素
remove(value): 移除鸠合中某个元素
clear(value): 清空鸠合
size(): 返回鸠合长度
values(): 返回鸠合转换的数组
union(otherSet): 返回两个鸠合的并集
intersection(otherSet): 返回两个鸠合的交集
difference(otherSet): 返回两个鸠合的差集
subset(otherSet): 推断该鸠合是不是为传入鸠合的子集
has要领:
申明:鸠合中元素是不反复的。所以在别的任何操纵前，必须用has要领确认鸠合是不是有某个元素。这儿使用了hasOwnProperty要领来检测。
完成:
/**
* 检测鸠合内是不是有某个元素
* @param {Any} value 要检测的元素
* @return {Boolean} 假如有，返回true
*/
this.has = function(value) {
// hasOwnProperty的问题在于
// 它是一个要领，所以可能会被覆写
return items.hasOwnProperty(value)
};add要领:
申明: 给鸠合内增加某个元素。
完成:
/**
* 给鸠合内增加某个元素
* @param {Any} value 要被增加的元素
* @return {Boolean} 增加胜利返回True。
*/
this.add = function(value) {
//先检测元素是不是存在。
if (!this.has(value)) {
items[value] = value;
return true;
}
//假如元素已存在则返回false
return false;
};remove要领:
申明: 移除鸠合中某个元素
完成:
/**
* 移除鸠合中某个元素
* @param {Any} value 要移除的元素
* @return {Boolean} 移除胜利返回True。
*/
this.remove = function(value) {
//先检测元素是不是存在。
if (this.has(value)) {
delete items[value];
return true;
}
//假如元素不存在，则删除失利返回false
return false;
};clear要领:
申明: 清空鸠合
完成:
/**
* 清空鸠合
*/
this.clear = function() {
this.items = {};
};size要领
申明: 返回鸠合长度，这儿有两种要领。第一种要领使用了Object.keys这个Api，但只支撑IE9及以上。第二种则适用于一切浏览器。
完成:
/**
* 返回鸠合长度，只可用于IE9及以上
* @return {Number} 鸠合长度
*/
this.size = function() {
// Object.keys要领能将对象转化为数组
// 只可用于IE9及以上，但很轻易
return Object.keys(items).length;
}
/**
* 返回鸠合长度，可用于一切浏览器
* @return {Number} 鸠合长度
*/
this.sizeLegacy = function() {
var count = 0;
for (var prop in items) {
if (items.hasOwnProperty(prop)) {
++count;
}
}
return count;
}values要领
申明: 返回鸠合转换的数组，这儿也有两种要领。来由同上。使用了Object.keys，只能支撑IE9及以上。
完成:
/**
* 返回鸠合转换的数组，只可用于IE9及以上
* @return {Array} 转换后的数组
*/
this.values = function() {
return Object.keys(items);
};
/**
* 返回鸠合转换的数组，可用于一切浏览器
* @return {Array} 转换后的数组
*/
this.valuesLegacy = function() {
var keys = [];
for (var key in items) {
keys.push(key)
};
return keys;
};union要领
申明: 返回两个鸠合的并集
完成:
/**
* 返回两个鸠合的并集
* @param {Set} otherSet 要举行并集操纵的鸠合
* @return {Set} 两个鸠合的并集
*/
this.union = function(otherSet) {
//初始化一个新鸠合，用于示意并集。
var unionSet = new Set();
//将当前鸠合转换为数组，并顺次增加进unionSet
var values = this.values();
for (var i = 0; i < values.length; i++) {
unionSet.add(values[i]);
}
//将别的鸠合转换为数组，顺次增加进unionSet。
//循环中的add要领保证了不会有反复元素的涌现
values = otherSet.values();
for (var i = 0; i < values.length; i++) {
unionSet.add(values[i]);
}
return unionSet;
};
intersection要领
申明: 返回两个鸠合的交集
完成:
/**
* 返回两个鸠合的交集
* @param {Set} otherSet 要举行交集操纵的鸠合
* @return {Set} 两个鸠合的交集
*/
this.intersection = function(otherSet) {
//初始化一个新鸠合，用于示意交集。
var interSectionSet = new Set();
//将当前鸠合转换为数组
var values = this.values();
//遍历数组，假如别的一个鸠合也有该元素，则interSectionSet到场该元素。
for (var i = 0; i < values.length; i++) {
if (otherSet.has(values[i])) {
interSectionSet.add(values[i])
}
}
return interSectionSet;
};difference要领
申明: 返回两个鸠合的差集
完成:
/**
* 返回两个鸠合的差集
* @param {Set} otherSet 要举行差集操纵的鸠合
* @return {Set} 两个鸠合的差集
*/
this.difference = function(otherSet) {
//初始化一个新鸠合，用于示意差集。
var differenceSet = new Set();
//将当前鸠合转换为数组
var values = this.values();
//遍历数组，假如别的一个鸠合没有该元素，则differenceSet到场该元素。
for (var i = 0; i < values.length; i++) {
if (!otherSet.has(values[i])) {
differenceSet.add(values[i])
}
}
return differenceSet;
};subset要领
申明: 推断该鸠合是不是为传入鸠合的子集。这段代码在我本身写完后与书上一比对，以为本身超等low。我写的要遍历数组三次，书上的只须要一次，算法复杂度远远低于我的。
完成:
/**
* 推断该鸠合是不是为传入鸠合的子集
* @param {Set} otherSet 传入的鸠合
* @return {Boolean} 是则返回True
*/
this.subset = function(otherSet) {
// 第一个剖断,假如该鸠合长度大于otherSet的长度
// 则直接返回false
if (this.size() > otherSet.size()) {
return false;
} else {
// 将当前鸠合转换为数组
var values = this.values();
for (var i = 0; i < values.length; i++) {
if (!otherSet.has(values[i])) {
// 第二个剖断。只需有一个元素不在otherSet中
// 那末则能够直接剖断不是子集，返回false
return false;
}
}
return true;
}
};源代码
源代码在此~
ES6中的鸠合
ES6也供应了鸠合，但之前看ES6的鸠合操纵一向模模糊糊的。完成一遍后再去看，觉得观点清楚了许多。
详细的我控制的不是很好，还在进修中，就不写出来啦~引荐看阮一峰先生的《ECMAScript 6入门》中对ES6 Set的引见。
感受
到了这儿，已控制了一些基础的数据结构。剩下的都是难啃的骨头了(对我而言)。
字典的散列表、图、树、排序算法。算是四大金刚，所以近期关于数据结构与算法系列的文章，可能会更新的很慢。对我来讲，也算是一个坎。愿望这个寒假，能跨过这个坎。
前端路漫漫，且行且歌~
