js 字典和散列表

最新推荐文章于 2024-01-13 07:15:00 发布
最新推荐文章于 2024-01-13 07:15:00 发布
阅读量560 收藏
点赞数
分类专栏： javascript
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_18304615/article/details/79567531
版权 
js字典 字典则是以[键，值]的形式来存储元素。字典也称作映射
function Dictionary() {
	var items = {};
	this.has = function(key) {
		return key in items;
	}
	this.set = function(key,value){
		items[key] = value;
	}
	this.remove = function(Key){
		if(this.has(Key)){
			delete items[Key];
			return true;
		}
		return false;
	}
	this.get = function(key){
		return this.has(Key)?items[Key]:undefined;
	}
	this.values = function() {
		var values = {};
		for (var k in items) { //{1}
			if (this.has(k)) {
				values.push(items[k]); //{2}
			}
		}	
		return values;
	};
	this.size = function(){
		return Object.keys(items).length; //{4}
	};
	this.sizeLegacy = function(){
		var count = 0;
		for(var prop in items) { //{5}
			if(items.hasOwnProperty(prop)) //{6}
				++count; //{7}
		}
		return count;
	};
	this.getItems = function() {
		return items;
	}
}

散列表

function HashTable() {
	var table = [];
	var loseloseHashCode = function (key) {
		var hash = 0;
		for(var i = 0;i<key.length;i++){
			hash += key.charCodeAt(i);
		}
		return hash % 37;
	}
	this.put = function(key,value){
		var position = this.loseloseHashCode(key);
		console.log(position + ' - ' + key);
		table[position] = value;
	}
	this.get = function(key){
		return table[this.loseloseHashCode(key)];
	}
	this.remove = function(key) {
		table[loseloseHashCode(key)] = undefined;
	};
	this.print = function() {
		for (var i = 0; i < table.length; ++i) { //{1}
			if (table[i] !== undefined) { //{2}
				console.log(i + ": " + table[i]);//{3}
			}
		}
	};
}

hash值相同的时候有冲突

19 - Gandalf
HashTable.js:12 29 - John
HashTable.js:12 16 - Tyrion
HashTable.js:12 16 - Aaron
HashTable.js:12 13 - Donnie
HashTable.js:12 13 - Ana
HashTable.js:12 5 - Jonathan
HashTable.js:12 5 - Jamie
HashTable.js:12 5 - Sue
HashTable.js:12 32 - Mindy
HashTable.js:12 32 - Paul
HashTable.js:12 10 - Nathan
HashTable.js:24 5: sue@email.com
HashTable.js:24 10: nathan@email.com
HashTable.js:24 13: ana@email.com
HashTable.js:24 16: aaron@email.com
HashTable.js:24 19: gandalf@email.com
HashTable.js:24 29: johnsnow@email.com
HashTable.js:24 32: paul@email.com
1. 分离链接
分离链接法包括为散列表的每一个位置创建一个链表并将元素存储在里面。它是解决冲突的

最简单的方法，但是它在 HashTable 实例之外还需要额外的存储空间。重写put get remove print'方法

function HashTable() {
	var table = [];
	var loseloseHashCode = function (key) {
		var hash = 0;
		for(var i = 0;i<key.length;i++){
			hash += key.charCodeAt(i);
		}
		return hash % 37;
	}
	this.put = function(key,value){
		var position = loseloseHashCode(key);
		//undefined创建链表
		if(table[position] == undefined)
			table[position] = new LinkedList();
			//undefined不为空 链表后面加元素
		table[position].append(new ValuePair(key,value));
	}
	this.get = function(key){
		var position = loseloseHashCode(key);
		if(table[position] !== undefined ){
			var current = table[position].getHead();
			while(current.next){
				if(current.element.key === key)
					return current.element.value;
				current = current.next;
			}
			if(current.element.key === key)
					return current.element.value;
		}
		return undefined;
	}
	this.remove = function(key) {
		var position = loseloseHashCode(key);
		if(table[position] !== undefined){
			var current = table[position].getHead();
			while(current.next){
				if(current.element.key === key){
					table[position].remove(current.element);
					if(table[position].isEmpty())
						table[position === undefined]
					return true;
				}
					
				current = current.next;
			}
			if(current.element.key === key){
					table[position].remove(current.element);
					if(table[position].isEmpty())
						table[position === undefined]
					return true;
			}
			return true;
		}
		return fasle;
	};
	this.print = function() {
		for (var i = 0; i < table.length; ++i) { //{1}
			if (table[i] !== undefined) { //{2}
				var current = table[i].getHead();
				while(current.next){
					console.info("output",current.element.toString());
					current = current.next;
				}
				console.info("output",current.element.toString());//{3}
			}
		}
	};
	//新增的方法 创建node元素 将key，value放入这个对象
	var ValuePair = function(key, value){
		this.key = key;
		this.value = value;
		console.info('[' + this.key + ' - ' + this.value + ']');
			
		this.toString = function() {
			return '[' + this.key + ' - ' + this.value + ']';
		}
	};
}
2. 线性探查
另一种解决冲突的方法是线性探查。当想向表中某个位置加入一个新元素的时候，如果索引
为index的位置已经被占据了，就尝试index+1的位置。如果index+1的位置也被占据了，就尝试

index+2的位置，以此类推

function HashTable() {
	var table = [];
	var loseloseHashCode = function (key) {
		var hash = 0;
		for(var i = 0;i<key.length;i++){
			hash += key.charCodeAt(i);
		}
		return hash % 37;
	}
	this.put = function(key,value){
		var position = loseloseHashCode(key);
		if(table[position] == undefined){
			table[position] = new ValuePair(key,value);
		}esle{
			var index = position;
			while(table[index] !== undefined){
				index++;
			}
			table[index] = new ValuePair(key,value);
		}
	}
	this.get = function(key){
		var position = loseloseHashCode(key);
		if(table[position] !== undefined ){
			if(table[position].key === key){
				return table[position].value;
			}else{
				var index =++position;
				while(table[index]===undefined||table[index].key!==key){
					index++
				}
				if(table[index].key===key){
					return table[index].value;
				}
			}
		}
		return undefined;
	}
	this.remove = function(key) {
		var position = loseloseHashCode(key);
		if(table[position] !== undefined ){
			if(table[position].key === key){
				 table[position] = undefined;
				 return true;
			}else{
				var index =++position;
				while(table[index]===undefined||table[index].key!==key){
					index++
				}
				if(table[index].key===key){
					table[position] = undefined;
					return true;
				}
			}
		}
		return false;
	};
	this.print = function() {
		for (var i = 0; i < table.length; ++i) { //{1}
			if (table[i] !== undefined) { //{2}
				console.info("output",table[i].toString());
			}
		}
	};
	//新增的方法 创建node元素 将key，value放入这个对象
	var ValuePair = function(key, value){
		this.key = key;
		this.value = value;
		console.info('[' + this.key + ' - ' + this.value + ']');
			
		this.toString = function() {
			return '[' + this.key + ' - ' + this.value + ']';
		}
	};
}
3.创建更好的散列函数
我们实现的“lose lose”散列函数并不是一个表现良好的散列函数，因为它会产生太多的冲
突。如果我们使用这个函数的话，会产生各种各样的冲突。一个表现良好的散列函数是由几个方
面构成的：插入和检索元素的时间（即性能），当然也包括较低的冲突可能性。我们可以在网上
找到一些不同的实现方法，或者也可以实现自己的散列函数

function HashTable() {
var table = [];
var loseloseHashCode = function (key) {
var hash = 5381;
for(var i = 0;i<key.length;i++){
hash += hash*33+key.charCodeAt(i);
}
return hash % 1013;
}
this.put = function(key,value){
var position = loseloseHashCode(key);
table[position] = new ValuePair(key,value);


}
this.get = function(key){
var position = loseloseHashCode(key);
if(table[position] !== undefined )
return table[position].value;
return undefined;
}
this.remove = function(key) {
var position = loseloseHashCode(key);
if(table[position] !== undefined ){
table[position] = undefined;
return true;
}
return false;
};
this.print = function() {
for (var i = 0; i < table.length; ++i) { //{1}
if (table[i] !== undefined) { //{2}
console.info("output",table[i].toString());
}
}
};
//新增的方法 创建node元素 将key，value放入这个对象
var ValuePair = function(key, value){
this.key = key;
this.value = value;
console.info('[' + this.key + ' - ' + this.value + ']');

this.toString = function() {
return '[' + this.key + ' - ' + this.value + ']';
}
};
}

最老狗
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JS中的算法与数据结构之字典(Dictionary)实例详解
12-12
本文实例讲述了JS中的算法与数据结构之字典(Dictionary)。分享给大家供大家参考，具体如下： 字典(Dictionary) 字典(Dictionary)是一种以 键-值对 形式存储数据的数据结构 ，就如同我们平时查看通讯录一样，要找一个电话，首先先找到该号码的机主名字，名字找到了，紧接着电话号码也就有了。这里的键就是你用来查找的东西，本例中指代的就是名字，值就是查找得到的结果，也就是对应的电话号码。 其实，JavaScript 中的 Object 类就是以字典的形式设计的，下面我们将会借助 Object 类的特性，自主实现一个 Dictionary 类，让这种字典类型的对象使用起来更
js之字典的学习和使用
热门推荐
Hei, Welcome To vickie's Blog，Good Good Study, Day Day Up ~
10-05 10万+
字典是一种以键-值对形式存储数据的数据结构，比如：名字-电话号码，通过名字就能找到对应的电话号码，名字就是键(key),电话号就是值(value)。字典中的键，是值在字典中的索引。对于javascript来说，字典类(Dictionary)的基础是Array类，js中的Array既是一个数组，同时也是一个字典。以下是通过3个示例来加深字典这种数据结构的理解和使用。
cocos creator学习之JavaScript的字典实现办法
LudoArtificis的成长之路
11-05 2410
function add(key, value){ // 添加字典的键值(key:value) this.dataStore[key] = value; } function show(){ //显示字典中的键值(key:value) for(var key in this.dataStore){ console.log(key + " ...
使用 js 实现 字典
樊小书生
02-05 5210
字典是一种以 键值对 形式存数数据的数据结构，javaScript 中的 Object 类就是以字典的形式设置的，所以使用 Object 类本身的特性实现字典 Dictionary 类。 属性及方法 列表 属性或方法 描述 add 方法 add(key, value) 向字典中添加 键值对 find 方法 find(key) 从字典中查找 key 键对应的值，找不到则返回 undefined remove 方法 remove(key) 从字典中删除 key 键 getKeys 方
JS中的字典和散列表
weixin_42274805的博客
06-28 551
介绍JS中的字典与散列表
MrDict.js:Javascript中字典数据结构的实验性简单实现
07-12
6. **性能优化**：为了提高效率，可能会有针对大数据量或高性能场景的优化措施，例如动态调整散列表大小或预计算散列值。 7. **测试覆盖率**：通过`npm test`运行的测试用例，验证了库的各个功能和边界条件，确保其...
JS数据结构与算法.pdf
11-01
此外，我们还讨论了数据结构，包括数组、栈、队列、链表、集合、字典、散列表、树、图等。最后，我们还讨论了算法，包括排序算法和搜索算法。 本书提供了详细的知识点和实践应用，帮助读者了解 JavaScript 数据结构...
data-structures:资料库和资料库
03-28
9. **散列表（字典）**：散列表提供键值对的快速存取，常用于数据库索引和缓存。JavaScript对象作为散列表使用时，键通常为字符串，而值可以是任意类型。 10. **图论算法**：包括深度优先搜索（DFS）、广度优先搜索...
data-structure-js:《数据结构与算法JavaScript描述》看书敲代码
05-17
散列表 散列的实现 散列表取值 碰撞处理-开链法 碰撞处理-线性探测 集合 集合的实现 元素按顺序存储的集合 二叉树 二叉树的实现 计数 图 图的实现 深度优先搜索 广度优先搜索 查找最短路径 拓扑排序 排序 数组测试...
javascript-datastructures-算法
01-30
学习JavaScript数据结构和算法基础（ ）栈（堆栈）类别（队列）链表（LinkedList）单链表（LinkedList）双链表（DoublyLinkedList）循环链表（CircularLinkedList）判断链表是否成环（LinkedListWithCycle）链表插入...
js(JavaScript)数据结构之字典
星辰迷上大海的博客
01-12 1520
字典是一种存储键-值对数据的数据结构，可以通过唯一的键来访问对应的值。这种数据结构可以在不需要使用数组的情况下，快速地查找、插入和删除数据。
js字典的操作
高压锅博客
08-27 4099
1. 字典的遍历 var dic={"a": "AA", "b": "BB", "c":"CC"} //不能length去for循环(length:undefined) dic["D"]="DD"; //新增键值对 var tmp=dic["D"]; //通过key获取值 for (var key in dic) { 　　var item = dic[key]; 　　console.log(item); //AA,BB,CC,DD } ...
js中字典的使用
HWQlet的博客
04-27 6193
字典是一种以键-值为一队存储的数据结构，key-value key相当于这个value在字典中的索引，所以key不允许重复，查找也会非常快（类似于哈希表） 在JavaScript中字典的基础是Array类，Array在JavaScript中既是数组也是字典 1.定义字典 var dic = new Array(); //定义一个字典 dic['one'] = '1'; //...
js 字典的使用（入门级）
敲代码无敌小奶龙的博客
01-18 3159
js 字典的使用
JavaScript散列表及其扩展
weixin_42274805的博客
07-17 170
接上文《JS中的字典和散列表》，我们来进一步了解散列表的应用。
js(JavaScript)数据结构之散列表（Hash）
最新发布
星辰迷上大海的博客
01-13 1299
散列表（Hash）是一种常用的数据结构，用于存储键值对。它利用散列函数将键映射到一个数字索引上，以便快速地插入、删除和查找数据。在JavaScript 中，可以使用对象来实现散列表的功能。
JS数据结构 之 散列表
RIN的博客
01-29 502
JS数据结构 之 散列表 散列、散列函数、散列表 散列 是一种常用的数据存储技术，散列后的数据可以快速地插入或取用。散列使用的数据结构叫做散列表**(哈希表-Hash Table)**。 散列表 ，是根据键（Key）直接访问在内存存储位置的数据结构。它通过计算一个关于键值的函数（散列函数），将所需查询的数据映射到表（散列表）中一个位置来访问记录。在散列表上插入、删除和取用数据都非常快。 散列表的作用：用于快速查找、防止重复、用作缓存 基于数组进行设计的散列表……
JavaScript数据结构与算法 - 散列表
友人A的博客
05-03 623
1. 概念 散列表： 散列表是字典的一种实现，所以可以用作关联数组。 散列表可以用来保存键和对表中记录的引用。如在关系型数据库中创建一个新的表时，同时创建一个索引可以更快查询到记录的key 可以使用散列表来表示对象。如JavaScript语言内部就是使用散列表来表示每个对象。 散列算法： 尽可能快地在数据结构中找到一个值。 不需要迭代整个数据结构来找到值。如果使用散列函数，就知道值的具体位置，因此能够快速检索到该值。 散列函数： 散列函数的作用是给定一个键值，然后返回值在表中的地址。 散列函数——
在 javascript 中循环遍历字典
迹忆客
06-30 3141
JavaScript 对象非常灵活，可用于创建键值对。这些对象的工作方式类似于 Python 字典。字典和对象之所以被广泛使用，是因为每个存储的值都有其唯一的键（类似于 JavaScript 数组），并且可以通过那些键访问那些值。这允许在读取和存储数据时具有出色的灵活性。今天的文章将教我们如何在 JavaScript 中迭代对象或字典来提取键值对。
字典和列表
05-30
举个例子，创建一个列表和一个字典： ```python # 列表 my_list = [1, 'hello', True] # 字典 my_dict = {'name': 'Alice', 'age': 20, 'gender': 'female'} ``` 访问列表和字典中的元素： ```python # 访问列表...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值