为什么一般hashtable的桶数会取一个素数

最新推荐文章于 2019-11-06 10:00:37 发布
最新推荐文章于 2019-11-06 10:00:37 发布
阅读量1.6k 收藏 1
点赞数
分类专栏： 算法
本文探讨了在哈希表中使用素数作为桶大小的原因。指出若桶大小选择非素数，则可能遇到hash结果分布不均的问题，尤其是在key与桶大小的因数相关时。而采用素数则能有效避免此类问题。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

http://blog.sina.com.cn/s/blog_8e9c63c70101g3ep.html



我个人认为更普遍意义的理解，如果不取素数的话是会有一定危险的，危险出现在当假设所选非素数m=x*y，如果需要hash的key正好跟这个约数x存在关系就惨了，最坏情况假设都为x的倍数，那么可以想象hash的结果为：1~y，而不是1~m。但是如果选桶的大小为素数是不会有这个问题。


哈希表的大小为什么最好为素数
langslin的博客
12-16 1753
哈希表的大小最好为素数？
为什么哈希表的长度应该是质数？
weixin_26713521的博客
09-13 2406
Every thorough data structures and algorithms course will cover the hash table data structure and, by extension, hash functions. In reviewing data structures recently, I came across the notion of redu...
hashtable桶数通常会取一个素数分析
08-31
主要介绍了hashtable桶数通常会取一个素数分析的相关资料,需要的朋友可以参考下
为什么hashtable中桶的数目都是用质数表示
xupeng1644的博客
11-06 3461
在查看hashtable源码的时候，我们会发现，hashtable的桶数全部使用的是质数，因为我们在hashtable的定义中，hash函数使用的是标准的求模函数，因此这样定义桶数有利于元素各个桶之间的均匀分布。 例子： 举一个有点极端的例子，假设我们的元素全是偶数1,4,6,8,10,12,14,1,6,18,20,22 如果我们使用4个桶： 0: 4,8,12,16.20 1： 2：6,10,...
[原创] 为什么模除的时候一般建议选择素数来除？比如说hashtable的桶数会取一个素数...
weixin_30483697的博客
08-11 235
设有一个哈希函数H( c ) = c % N;当N取一个合数时，最简单的例子是取2^n，比如说取2^3=8,这时候H( 11100(二进制） ) = H( 28 ) = 4H( 10100(二进制) ) = H( 20 ）= 4 因为除以一个2^n，可以看为向左移动n位，而模除得到的余数其实就是这移掉的n位数，因此在这种情况下，除开这低位的n位数以外，剩余的高位数所有位都没有利用上，也就是说无论...
利用C语言实现HashTable
09-05
哈希表的大小被设置为一个质数，这是因为质数可以减少哈希冲突的概率。 在插入键值对之前，我们需要一个哈希函数来计算键的哈希值。提供的`hashcode`函数基于ELF哈希算法，它将字符串转换为整数，通过位运算减少...
hashtable:C语言中的异步哈希表服务器
04-28
随机素数生成的通用哈希算法 霍纳法则的字符串哈希 当填充率> = 0.5时自动扩展表格大小 建造 与无业游民： git clone git@github.com:dizballanze/hashtable.git cd hashtable vagrant up vagrant ssh cd proj ...
为什么hashtable桶数通常会取一个素数？如何有效避免hash结果值的碰撞
single6的博客
08-02 3075
为什么一般hashtable的桶数会取一个素数 假如有一个哈希函数：H( c ) = c % N; 当N取一个合数时，最简单的例子是取2^n，比如说取2^3=8,这时候 H( 11100(二进制） ) = H( 36 ) = 4 H( 10100(二进制) ) = H( 28）= 4 这时候c的二进制第4位（从右向左数）就”失效”了，也就是说，无论第c的4位取什么值，都会导致H( c )...
为什么Hashtab的大小通常取远离2^n 的素数
杨博东的博客
03-11 744
举个栗子在Hashtab中我们通常 Hash(key) % M 来确定 key 所需要存放的位置M就是Hashtab的大小，假设下面的两个场景Hash(key1) = 108 Hash(key2) = 500 如果 M 恰好是 2^n，我们在这里假设M为2^3=8则 Hash(key1) % M = 108 % 8 = 4Hash(key2) % M = 500% 8 = 4此时最后的结果
哈希表中数组的容量为什么是质数
Mark2When的博客
05-01 4276
哈希表中数组的容量为什么是质数   1、HASH函数需要把原始数据均匀地分布到HASH数组里，比如大部分是偶数，这时候如果HASH数组容量是偶数，容易使原始数据HASH后不会均匀分布：   2 4 6 8 10 12这6个数，如果对 6 取余 得到 2 4 0 2 4 0 只会得到3种HASH值，冲突会很多。如果对 7取余 得到 2 4 6 1 3 5 得到6种HASH值，没有
hashtable桶大小取质数
bxw1992的博客
08-09 2814
为什么Hashtable的vector大小（也叫桶大小）选取质数？        是为了减少哈希冲突。        桶大小的选取是如何影响哈希冲突的呢？下面有两种看法：        1、举个例子，对于除法哈希表（Division method）h(k)=k mod m注意二进制数对取余就是该二进制数最后r位数。这样一来，Hash函数就和键值（用二进制表示）的前几位数无关了，这样我们就没有
哈希表除留取余法的桶个数为什么是质数
Ilozk的专栏
06-04 6415
可先科普下质数的概念：质数，也就是素数，就是指一个大于1的自然数，约数（因数）只有1和它自己，否则叫合数。 除留取余，就是哈希函数将关键字被某个不大于哈希表长m的数p除后所得余数为哈希地址。这是最常用、也最简单的构造哈希函数的方法。当然，也可以对关键字直接取模，也可以折叠、平方取中等运算后取模。那么问题来了，这个p取多大呢？p的取值不好，会不会造成哈希函数的不均匀？先看一个简单的例子： 有一个...
从十七年蝉谈起——hashtable的表格大小为什么要选择质数
hiyajo_salieri的博客
03-30 1538
十七年蝉，同翅目。北美洲一种穴居十七年才能化羽而出的蝉。它们在地底蛰伏17年始出，尔后附上树枝蜕皮，然后交配。雄蝉交配后即死去，母蝉亦于产卵后死。科学家解释，十七年蝉的这种奇特生活方式，为的是避免天敌的侵害并安全延续种群，因而演化出一个漫长而隐秘的生命周期。 这是百度百科里关于十七年蝉的介绍，十七年蝉是一个非常奇怪的蝉类，它的生命轮回周期是13年或者17年这样的质数年份。
hash函数为什么要选择对素数求余？
泡飞的博客
12-20 5953
hash函数为什么要选择对素数求余？ 问题来源？   引出此问题，是看到一篇有关jdk中HashMap和Hashtable对于hash算法的选择。 HashMap中对key求完hash值，在进行数组寻址时，使用的方法是位运算（代替的取模运算）。公式如下： (length - 1) & hash // length为HashMap的容量，是2的n次方   在这里插播一个小知识...
使用Python用一个HashTable类来实现ADT Map
最新发布
04-04
<think>嗯，用户让我用Python实现一个HashTable类来实现ADT Map。首先，我得回忆一下ADT Map的基本操作。Map通常需要支持插入、查找、删除和判断键是否存在，可能还需要获取大小。所以HashTable类需要实现这些方法。 接下来，哈希表的原理。哈希表通过哈希函数将键转换成索引，然后在对应的位置存储值。处理冲突的方法有很多，比如链地址法或者开放寻址法。Python中通常用链地址法，每个槽位放一个链表或者列表，这样冲突的时候可以追加到后面。 那哈希函数的设计。简单的可以用取模运算，比如用哈希表的大小作为模数。不过要注意哈希表的大小应该是一个质数，这样可以减少冲突。这里可能需要一个获取下一个质数的方法，当扩容的时候需要用到。 然后考虑负载因子，当元素数量超过负载因子和容量的乘积时，就需要扩容。通常负载因子设为0.75比较合适。扩容的时候，需要创建一个更大的哈希表，通常是两倍左右的大小，并且重新哈希所有现有的键值对。 哈希表的大小最好是质数，所以需要有一个方法来找到下一个质数。比如，当需要扩容时，检查当前大小的两倍是否是质数，如果不是，就找比它大的下一个质数。 现在具体到类的结构。HashTable类应该有属性：容量（初始设为11），大小（当前存储的键值对数量），负载因子阈值，以及存储桶（buckets），每个桶是一个列表，里面存放键值对的元组。 初始化的时候，buckets应该是容量个空列表。插入的时候，计算哈希值找到对应的桶，然后遍历这个桶里的元素，如果键已经存在，就更新值；否则添加新的键值对。插入后检查负载因子，超过阈值就扩容。 查找的时候，同样计算哈希找到桶，遍历桶里的元素找到对应的键，返回值，找不到的话可以抛出KeyError或者返回None。 删除操作类似，找到桶后遍历，找到对应的键然后移除，同时减少大小。 还需要一个哈希函数，这里可以先用Python内置的hash()函数，然后取模当前容量。不过要注意，如果键是自定义对象，可能需要自己实现__hash__方法，但这里假设用户使用的是基本数据类型或Python处理好的对象。 测试的时候，可能需要处理各种情况，比如冲突、扩容等。比如插入多个键，导致负载因子超过阈值，触发扩容，这时候容量会变成下一个质数，比如23，然后重新哈希所有元素。 可能的错误点：哈希函数处理负数的情况，取模后要确保是正数。另外，删除元素时，如果在遍历列表的时候修改列表，可能会出问题，所以需要正确处理。 另外，实现__contains__方法可以用in操作符，直接调用get方法检查是否存在。 最后，可能需要一些辅助方法，比如获取所有键、所有值，或者遍历键值对，但根据ADT Map的基本要求，这些可能不是必须的，但用户可能需要扩展。 总结一下步骤： 1. 定义HashTable类，初始化容量、大小、buckets和负载因子阈值。 2. 实现哈希函数。 3. 实现插入、查找、删除等方法。 4. 处理扩容逻辑，包括找到下一个质数和重新哈希。 5. 测试各个方法是否正确，特别是冲突和扩容的情况。</think>以下是用Python实现`HashTable`类来表示ADT Map的逐步说明，采用链地址法解决哈希冲突： $$ \text{哈希表结构: } TableSize \times [ (key_1, value_1) \rightarrow (key_2, value_2) \rightarrow ... ] $$ ### 1. 类结构定义 ```python class HashTable: def __init__(self, initial_capacity=11, load_factor=0.75): self.capacity = self._next_prime(initial_capacity) # 初始容量为质数 self.size = 0 # 当前存储的键值对数量 self.load_factor = load_factor self.buckets = [[] for _ in range(self.capacity)] # 存储桶的二维列表 ``` ### 2. 哈希函数实现 $$ \text{哈希函数: } h(key) = \text{hash}(key) \mod capacity $$ ```python def _hash(self, key): return hash(key) % self.capacity # 使用Python内置哈希函数 ``` ### 3. 插入操作 $$ \text{插入时间复杂度: } O(1) \text{(平均情况)} $$ ```python def put(self, key, value): index = self._hash(key) bucket = self.buckets[index] # 检查是否已存在相同key for i, (k, v) in enumerate(bucket): if k == key: bucket[i] = (key, value) return # 添加新键值对 bucket.append((key, value)) self.size += 1 # 检查是否需要扩容 if self.size / self.capacity > self.load_factor: self._resize() ``` ### 4. 动态扩容机制 $$ \text{新容量} = \text{next_prime}(2 \times \text{old\_capacity}) $$ ```python def _resize(self): new_capacity = self._next_prime(2 * self.capacity) new_buckets = [[] for _ in range(new_capacity)] # 重新哈希所有现有元素 old_buckets = self.buckets self.capacity = new_capacity self.buckets = new_buckets self.size = 0 for bucket in old_buckets: for key, value in bucket: self.put(key, value) ``` ### 5. 查找操作 $$ \text{查找时间复杂度: } O(1) \text{(平均情况)} $$ ```python def get(self, key): index = self._hash(key) bucket = self.buckets[index] for k, v in bucket: if k == key: return v raise KeyError(f"Key {key} not found") ``` ### 6. 删除操作 $$ \text{删除时间复杂度: } O(1) \text{(平均情况)} $$ ```python def remove(self, key): index = self._hash(key) bucket = self.buckets[index] for i, (k, v) in enumerate(bucket): if k == key: del bucket[i] self.size -= 1 return raise KeyError(f"Key {key} not found") ``` ### 7. 辅助方法 ```python def __contains__(self, key): try: self.get(key) return True except KeyError: return False def __len__(self): return self.size def _next_prime(self, n): # 查找大于等于n的最小质数 def is_prime(num): if num < 2: return False for i in range(2, int(num**0.5)+1): if num % i == 0: return False return True while True: if is_prime(n): return n n += 1 ``` ### 使用示例 ```python ht = HashTable() ht.put("apple", 5) # 插入键值对 ht.put("banana", 10) print(ht.get("apple")) # 输出: 5 print(len(ht)) # 输出: 2 ht.remove("banana") print("banana" in ht) # 输出: False ``` ### 关键特性 1. **自动扩容**：当负载因子超过阈值时自动扩容 2. **质数容量**：始终使用质数作为容量，减少哈希冲突 3. **链地址法**：每个桶使用列表存储冲突元素 4. **完整API**：实现`put/get/remove/__len__/__contains__`等标准Map操作
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值