摘要：什么是散列表和散列函数哈希表，也叫散列表，是根据关键码值而直接进行访问的数据结构。根据键值从散列表中移除值。请实现散列表将和存在一个对象中即可定义一个包含和属性的类并分配到散列表。
这是第五周的练习题，上周忘记发啦，这周是复习 Dictionary 和 HashTable。
下面是之前分享的链接：
1.每周一练 之 数据结构与算法（Stack）
2.每周一练 之 数据结构与算法（LinkedList）
3.每周一练 之 数据结构与算法（Queue）
4.每周一练 之 数据结构与算法（Set）
欢迎关注我的 个人主页 && 个人博客 && 个人知识库 && 微信公众号“前端自习课”
本周练习内容：数据结构与算法 —— Dictionary 和 HashTable
这些都是数据结构与算法，一部分方法是团队其他成员实现的，一部分我自己做的，有什么其他实现方法或错误，欢迎各位大佬指点，感谢。
一、字典和散列表的概念字典是什么？
字典和集合有什么异同？
什么是散列表和散列函数？
散列表的特点是什么？
解析：
字典是什么？
字典是一种以 键-值对 形式存储数据的数据格式，其中键名用来查询特定元素。
字典和集合有什么异同？
相同：都是用来存储不同元素的数据格式；
区别：集合是以 值-值 的数据格式存储，而字典是以 键-值 的数据格式存储。
什么是散列表和散列函数？
哈希表（Hash table，也叫散列表），是根据关键码值(·Key value·)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。
散列表的特点是什么？
特点：数组和链接优点的结合，查询速度非常的快，几乎是O(1)的时间复杂度，并且插入和删除也容易。
二、请实现一个字典set(key,value)：向字典中添加新元素。
delete(key)：通过使用键值从字典中移除键值对应的值。
has(key)：如果某个键值存在于这个字典中，则返回 true，否则返回 false。
get(key)：使用键值查找对应的值并返回。
clear()：删除字典中的所有元素。
size()：返回字典包含的元素数量，与数组的 length 属性类似。
keys()：将字典的所有键名以数组的形式返回。
values()：将字典包含的所有数值以数组形式返回。
使用示例：
let dictionary = new Dictionary();
dictionary.set("Gandalf", "gandalf@email.com");
dictionary.set("John", "johnsnow@email.com");
dictionary.set("Tyrion", "tyrion@email.com");
console.log(dictionary.has("Gandalf"));
console.log(dictionary.size());
console.log(dictionary.keys());
console.log(dictionary.values());
console.log(dictionary.get("Tyrion"));
dictionary.delete("John");
console.log(dictionary.keys());
console.log(dictionary.values());
提示：Web 端优先使用 ES6 以上的语法实现。
解析：
// 二、请实现一个字典
class Dictionary {
constructor(){
this.items = []
}
/**
* 向字典中添加新元素
* @param {*} key 添加的键名
* @param {*} value 添加的值
*/
set (key, value) {
if ( !key ) return new Error("请指定插入的key")
this.items[key] = value
}
/**
* 查询某个键值存在于这个字典
* @param {*} key 查询的键名
* @return {Boolean} 是否存在
*/
has (key) {
return key in this.items
}
/**
* 通过使用键值从字典中移除键值对应的值
* @param {*} key 移除的键名
* @return {Boolean} 是否移除成功
*/
delete (key) {
if(!key || !this.has(key)) return false
delete this.items[key]
return true
}
/**
* 使用键值查找对应的值并返回
* @param {*} key 查找的键名
* @return {*} 查找的结果
*/
get (key) {
return this.has(key) ? this.items[key] : undefined
}
/**
* 删除字典中的所有元素
*/
clear () {
this.items = {}
}
/**
* 将字典的所有键名以数组的形式返回
* @return {Array} 所有键名的数组
*/
keys () {
return Object.keys(this.items)
}
/**
* 将字典的所有键值以数组的形式返回
* @return {Array} 所有键值的数组
*/
values () {
let result = []
for(let k in this.items){
if(this.has[k]){
result.push(this.items[k])
}
}
return result
}
/**
* 返回字典包含的元素数量
* @return {Number} 元素数量
*/
size () {
const values = this.values()
return values.length
}
}
三、请实现一个散列表
put(key,value)：向散列表增加/更新一个新的项。
remove(key)：根据键值从散列表中移除值。
get(key)：根据键值检索到特定的值。
print()：打印散列表中已保存的值。
散列表内部的散列算法：
function hashCode(key) {
let hash = 0;
for (let i = 0; i < key.length; i++) {
hash += key.charCodeAt(i);
}
return hash % 37;
}
使用示例：
const hashTable = new HashTable();
hashTable.put("Gandalf", "gandalf@email.com");
hashTable.put("John", "johnsnow@email.com");
hashTable.put("Tyrion", "tyrion@email.com");
hashTable.print();
解析：
// 三、请实现一个散列表
class HashTable {
constructor(){
this.table = []
}
/**
* 散列函数
* @param {*} key 键名
*/
hashCode(key) {
let hash = 0;
for (let i = 0; i < key.length; i++) {
hash += key.charCodeAt(i);
}
return hash % 37;
}
/**
* 向散列表增加/更新一个新的项
* @param {*} key 添加的键名
* @param {*} value 添加的值
*/
put (key, value) {
let position = this.hashCode(key)
this.table[position] = value
}
/**
* 根据键值从散列表中移除值
* @param {*} key 移除的键名
* @return {Boolean} 是否成功移除
*/
remove (key) {
if ( !key ) return false
let position = this.hashCode(key)
this.table[position] = undefined
return true
}
/**
* 根据键值检索到特定的值
* @param {*} key 查找的键名
* @return {*} 查找的值
*/
get (key) {
let position = this.hashCode(key)
return this.table[position]
}
/**
* 打印散列表中已保存的值
* @return {*} 散列表的值
*/
print () {
return this.table
}
}
四、请利用之前已实现的链表，实现一个分离链接的散列表
分离链接是为散列表的每一个位置创建一个链表储存元素的方式来处理散列表中的冲突：
请实现新的散列表方法：
put(key,value)：将 key 和 value 存在一个 ValuePair 对象中（即可定义一个包含 key 和 value 属性的 ValuePair` 类），并将其加入对应位置的链表中。
get(key)：返回键值对应的值，没有则返回 undefined。
remove(key)：从散列表中移除键值对应的元素。
print()：打印散列表中已保存的值。
提示：先找到元素储存位置所对应的链表，再找到对应的值。
const hashTable = new HashTable();
hashTable.put("Gandalf", "gandalf@email.com");
hashTable.put("Tyrion", "tyrion@email.com");
hashTable.put("Aaron", "aaron@email.com");
hashTable.put("Ana", "ana@email.com");
hashTable.put("Mindy", "mindy@email.com");
hashTable.put("Paul", "paul@email.com");
hashTable.print();
console.log(hashTable.get("Tyrion"));
console.log(hashTable.get("Aaron"));
hashTable.remove("Tyrion");
hashTable.print();
解析：
// 链表的实现代码省略 可以查看之前的代码
let ValuePair = function (key, value){
this.key = key
this.value = value
this.toString = function(){
return `[${this.key} - ${this.value}]`
}
}
class HashTable {
constructor(){
this.table = []
}
/**
* 散列函数
* @param {*} key 键名
*/
hashCode(key) {
let hash = 0;
for (let i = 0; i < key.length; i++) {
hash += key.charCodeAt(i);
}
return hash % 37;
}
/**
* 向散列表增加/更新一个新的项
* @param {*} key 添加的键名
* @param {*} value 添加的值
*/
put (key, value) {
let position = this.hashCode(key)
if(this.table[position] == undefined){
this.table[position] = new LinkedList()
}
this.table[position].append(new ValuePair(key, value))
}
/**
* 根据键值从散列表中移除值
* @param {*} key 移除的键名
* @return {Boolean} 是否成功移除
*/
remove (key) {
let position = this.hashCode(key)
if ( !key || this.table[position] === undefined ) return false
let current = this.table[position].getHead()
while(current.next){
if(current.element.key === key){
this.table[position].remove(current.element)
if(this.table[position].isEmpty){
this.table[position] = undefined
}
return true
}
current = current.next
}
}
/**
* 根据键值检索到特定的值
* @param {*} key 查找的键名
* @return {*} 查找的值
*/
get (key) {
let position = this.hashCode(key)
if(!key || this.table[position] === undefined) return undefined
let current = this.table[position].getHead()
while(current.next()){
if(current.element.key === key){
return current.element.value
}
current = current.next
}
}
/**
* 打印散列表中已保存的值
* @return {*} 散列表的值
*/
print () {
return this.table
}
}
五、实现一个线性探查的散列表
线性探查是解决散列表中冲突的另一种方法，当向表中某一个位置加入新元素的时候，如果索引为 index 的位置已经被占据了，就尝试 index+1 的位置。如果 index+1 的位置也被占据，就尝试 index+2，以此类推。
请实现散列表：
put(key,value)：将 key 和 value 存在一个 ValuePair 对象中（即可定义一个包含 key 和 value 属性的 ValuePair 类）并分配到散列表。
get(key)：返回键值对应的值，没有则返回 undefined。
remove(key)：从散列表中移除键值对应的元素。
提示：移除一个元素，只需要将其赋值为 undefined。
使用示例：
const hashTable = new HashTable();
hashTable.put("Gandalf", "gandalf@email.com");
hashTable.put("Tyrion", "tyrion@email.com");
hashTable.put("Aaron", "aaron@email.com");
hashTable.put("Ana", "ana@email.com");
hashTable.put("Mindy", "mindy@email.com");
hashTable.put("Paul", "paul@email.com");
hashTable.print();
console.log(hashTable.get("Tyrion"));
console.log(hashTable.get("Aaron"));
hashTable.remove("Tyrion");
hashTable.print();
解析：
let ValuePair = function (key, value){
this.key = key
this.value = value
this.toString = function(){
return `[${this.key} - ${this.value}]`
}
}
class HashTable {
constructor(){
this.table = []
}
/**
* 散列函数
* @param {*} key 键名
*/
hashCode(key) {
let hash = 0;
for (let i = 0; i < key.length; i++) {
hash += key.charCodeAt(i);
}
return hash % 37;
}
/**
* 向散列表增加/更新一个新的项
* @param {*} key 添加的键名
* @param {*} value 添加的值
*/
put (key, value) {
let position = this.hashCode(key)
if(this.table[position] == undefined){
this.table[position] = new ValuePair(key, value)
}else{
let index = ++position
while(this.table[index] !== undefined){
index ++
}
this.table[index] = new ValuePair(key, value)
}
}
/**
* 根据键值从散列表中移除值
* @param {*} key 移除的键名
* @return {Boolean} 是否成功移除
*/
remove (key) {
let position = this.hashCode(key)
if( !key || this.table[position] === undefined ) return undefined
if(this.table[position].key === key){
this.table[index] = undefined
}else{
let index = ++position
while(
this.table[index] === undefined ||
this.table[index].key !== key
){
index ++
}
if(this.table[index].key === key){
this.table[index] = undefined
}
}
}
/**
* 根据键值检索到特定的值
* @param {*} key 查找的键名
* @return {*} 查找的值
*/
get (key) {
let position = this.hashCode(key)
if( !key || this.table[position] === undefined ) return undefined
if(this.table[position].key === key){
return this.table[position].value
}else{
let index = ++position
while(
this.table[index] === undefined ||
this.table[index].key !== key
){
index ++
}
if(this.table[index].key === key){
return this.table[index].value
}
}
}
/**
* 打印散列表中已保存的值
* @return {*} 散列表的值
*/
print () {
return this.table
}
}
下周预告
下周将练习 Tree 的题目。
文章版权归作者所有，未经允许请勿转载,若此文章存在违规行为，您可以联系管理员删除。
转载请注明本文地址：https://www.ucloud.cn/yun/109681.html
摘要：什么是散列表和散列函数哈希表，也叫散列表，是根据关键码值而直接进行访问的数据结构。将字典的所有键名以数组的形式返回。根据键值从散列表中移除值。这是第五周的练习题，上周忘记发啦，这周是复习 Dictionary 和 HashTable。 下面是之前分享的链接： 1.每周一练 之 数据结构与算法（Stack） 2.每周一练 之 数据结构与算法（LinkedList） 3.每周一练 之 数据结构...
摘要：一集合是什么与它相关数学概念有哪些解题集合定义集合是一种包含不同元素的数据结构。集合中的元素称为成员，集合最重要的两个特点集合中的成员是无序集合中不存在相同成员即无序且唯一。 showImg(https://segmentfault.com/img/remote/1460000019005270); 这是第四周的练习题，五一放假结束，该收拾好状态啦。 下面是之前分享的链接： ...
摘要：假设一个二叉搜索树具有如下特征节点的左子树只包含小于当前节点的数。所有左子树和右子树自身必须也是二叉搜索树。代码实现二叉树节点定义来源验证二叉搜索树解析 showImg(https://segmentfault.com/img/remote/1460000019005270); 这是第六周的练习题，最近加班比较多，上周主要完成一篇 GraphQL入门教程 ，有兴趣的小伙伴可以看下哈。 ...
摘要：假设一个二叉搜索树具有如下特征节点的左子树只包含小于当前节点的数。所有左子树和右子树自身必须也是二叉搜索树。代码实现二叉树节点定义来源验证二叉搜索树解析这是第六周的练习题，最近加班比较多，上周主要完成一篇 GraphQL入门教程 ，有兴趣的小伙伴可以看下哈。 下面是之前分享的链接： 1.每周一练 之 数据结构与算法（Stack） 2.每周一练 之 数据结构与算法（LinkedList） 3...
摘要：与堆栈区别队列的操作方式和堆栈类似，唯一的区别在于队列只允许新数据在后端进行添加。移除队列的第一项，并返回被移除的元素。三使用队列计算斐波那契数列的第项。前两项固定为，后面的项为前两项之和，依次向后。 showImg(https://segmentfault.com/img/remote/1460000019005270); 这是第二周的练习题，这里补充下咯，五一节马上就要到了，自己的...
阅读 1399·2021-09-28 09:44
阅读 2480·2021-09-28 09:36
阅读 1027·2021-09-08 09:35
阅读 1966·2019-08-29 13:50
阅读 790·2019-08-29 13:29
阅读 1104·2019-08-29 13:15
阅读 1705·2019-08-29 13:00
阅读 2954·2019-08-26 16:16
