基本的数据结构
function Set() {
// collection 变量用来存储集合中的元素
var collection = [];
// 当集合中存在 element 元素时返回 true 否则返回 false
this.has = function(element) {
return (collection.indexOf(element) !== -1);
};
// 该方法会返回集合内所有元素
this.values = function() {
return collection;
};
}
添加一个 add 方法。 由于 set 集合当中不存在重复元素。因此在添加之前,首先需要进行判断该元素是否存在。
this.add = function (element) {
if (!this.has(element)) {
collection.push(element);
return true;
}
return false;
};
添加一个 remove 方法。判断该元素是否在集合中。若存在,则删除
this.remove = function (element) {
if (this.has(element)) {
for (let i = 0; i < collection.length; i++) {
if (collection[i] === element) {
collection.splice(i, 1)
return true
}
}
} else {
return false
}
}
//-------
this.remove = function (element) {
if (this.has(element)) {
var index = collection.indexOf(element);
collection.splice(index, 1);
return true;
}
return false;
};
添加一个 size 方法。返回集合中元素的个数
this.size = function() {
return collection.length
}
添加一个求两个集合的并集
this.union = function (set) {
const newSet = new Set();
this.values().forEach(value => {
newSet.add(value);
})
set.values().forEach(value => {
newSet.add(value);
})
return newSet;
}
this.union = function (anotherSet) {
const newSet = new Set();
const addToSet = el => newSet.add(el);
this.values().forEach(addToSet);
anotherSet.values().forEach(addToSet);
return newSet;
}
添加一个方法,求两个集合的交集
this.intersection = function (otherSet) {
var intersectionSet = new Set();
var firstSet = this.values();
firstSet.forEach(function (e) {
if (otherSet.has(e)) {
intersectionSet.add(e);
}
});
return intersectionSet;
};
参考答案解法
this.intersection = function (set) {
const newSet = new Set();
let largeSet;
let smallSet;
if (this.dictionary.length > set.length) {
largeSet = this;
smallSet = set;
} else {
largeSet = set;
smallSet = this;
}
smallSet.values().forEach(value => {
if (largeSet.dictionary[value]) {
newSet.add(value);
}
})
return newSet;
}
添加一个 difference 方法。求两个集合的差异
this.difference = function (otherSet) {
let differenceSet = new Set()
let firstSet = this.values()
firstSet.forEach(function (e) {
if (!otherSet.has(e)) {
differenceSet.add(e)
}
})
return differenceSet
}
添加一个 subset 方法。求某个集合是否为另一个集合的子集。
this.subset = function (otherSet) {
let firstSet = this.values()
firstSet.forEach(function (e) {
if (otherSet.has(e)) {
return true
}
return false
})
}
当然 ES6 的 set 数据结构的内部实现肯定比这个要更加完善,也更加高效。
Map 是一种存储键值对的数据结构。在 JavaScript 中,对象就是 Map 的一种表现形式。Map 是一种十分通用和高效的数据查询结构,我们可以在 Map 中通过 key(键)快速地获取对应的 value(值)。
var Map = function() {
this.collection = {}
}
add
方法接收key
和value
作为参数,并把键值对添加到 Map 中
this.add = (key, value) => {
this.collection[key] = value
}
remove
方法接收一个key
值并移除对应的键值对
this.remove = (key) => {
if (this.has(key)) {
delete this.collection[key];
}
}
get
方法接收key
值,并返回对应的value
值
this.get = (key) => {
if (this.has(key)) {
return this.collection[key];
} else {
return undefined;
}
}
has
方法根据值的存在情况返回相应的boolean
值
this.has = (key) => {
return this.collection.hasOwnProperty(key)
}
values
方法以数组形式返回 Map 中所有的 value
this.values = () => {
return [...Object.values(this.collection)]
}
size
方法返回 Map 中元素的个数
this.size = () => {
return Object.entries(this.collection).length
}
clear
清空 Map。
this.clear = () => {
this.collection = {}
}
哈希表接收一个 key 作为参数,并以特定的方式把 key 转换为一串数字。该数字串会与 value 值建立对应关系,并存储到表中。如果你想获取该 key 值,hashing 函数会接收 key 作为参数,并经过计算后得到与存储时的 key 相同的数字串,然后通过该数字串获取对应的 value。这种查询方式非常高效,平均时间复杂度为 O(n)。
试想一下,假如两个不同的 key 值通过同一个 hash 函数产生了相同的值怎么办?我们称这种情况为 collision(冲突)。解决冲突的一种方式是将键值对存入该 index 中。在查询时,你需要遍历一下这个 index 上存储的所有数据,找出你需要的那一条。一个好的 hash 函数应维持较低的冲突发生率,以保证查询效率。
var called = 0;
var hash = (string) => {
called++;
var hash = 0;
for (var i = 0; i < string.length; i++) { hash += string.charCodeAt(i); }
return hash;
};
var HashTable = function () {
this.collection = {}
}
add 方法接收一个键值对参数并把它存储到哈希表中
this.add = function (key, val) {
var theHash = hash(key);
if (!this.collection.hasOwnProperty(theHash)) {
this.collection[theHash] = {};
}
this.collection[theHash][key] = val;
}
remove 方法接收一个 key 为参数并移除对应的键值对
this.remove = function (key) {
var hashedObj = this.collection[hash(key)];
if (hashedObj.hasOwnProperty(key)) {
delete hashedObj[key];
}
if (!Object.keys(hashedObj).length) {
delete this.collection[hash(key)];
}
}
lookup 方法接收一个 key 为参数并返回对应的 value 值,如果 key 值不存在就返回 null。
this.lookup = function (key) {
var theHash = hash(key);
if (this.collection.hasOwnProperty(theHash)) {
return this.collection[theHash][key];
}
return null
}
希望各位小伙伴自己实现一下。
当然有的人会说,就这。。。。
确实,笔者的文章都很普通。不是那种特别高深的文章,也没啥干货可以分享。只不过是把自己学习过程中的一点收货分享出来。