[原创] 为什么模除的时候一般建议选择素数来除？比如说hashtable的桶数会取一个素数...

最新推荐文章于 2021-01-05 21:38:17 发布
最新推荐文章于 2021-01-05 21:38:17 发布
阅读量257 收藏
点赞数
CC 4.0 BY-SA版权
原文链接：http://www.cnblogs.com/lordcheng/p/7344652.html

设有一个哈希函数
H( c ) = c % N;
当N取一个合数时，最简单的例子是取2^n，比如说取2^3=8,这时候
H( 11100(二进制） ) = H( 28 ) = 4
H( 10100(二进制) ) = H( 20 ）= 4

因为除以一个2^n，可以看为向左移动n位，而模除得到的余数其实就是这移掉的n位数，因此在这种情况下，除开这低位的n位数以外，剩余的高位数所有位都没有利用上，也就是说无论高位上的位取什么数，都对最后的余数不影响，从而有很多不同的数，但由于低n位是一样的，所以依然发生冲突。也就是导致冲突的几率增大。

关于为什么模除以素数就比除以合数冲突概率小？以下是个人推测：

　　当除以一个素数的时候(素数定义：只有1和它本身两个因数的自然数)，由于该数不是2的倍数，因此除法不能完整的说是左右多少位，如果硬要除以该素数按进行移位来算的话，可以说移掉的低多少位，不再是一个整数，那么模除将影响的不再是低多少位数，而是相比于合数来说，要影响更多位，甚至说基本上会影响一个数所有的而二进制位。从而让一个数的所有二进制位都对最后产生的模除结果发挥了作用，相比于模除一个合数仅仅是低n位发挥作用来说，模除以一个素数发生冲突的概率就会更小。

　　

转载于:https://www.cnblogs.com/lordcheng/p/7344652.html

哈希表的大小为什么最好为素数
langslin的博客
12-16 1807
哈希表的大小最好为素数？
为什么哈希表的长度应该是质数？
weixin_26713521的博客
09-13 2458
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的桶数会取一个素数
热门推荐
671coder的专栏
11-07 3万+
为什么一般hashtable的桶数会取一个素数  设有一个哈希函数 H( c ) = c % N; 当N取一个合数时，最简单的例子是取2^n，比如说取2^3=8,这时候 H( 11100(二进制） ) = H( 28 ) = 4 H( 10100(二进制) ) = H( 20 ）= 4 这时候c的二进制第4位（从右向左数）就”失效”了，也就是说，无论第c的4位取什么值，
hashtable桶数通常会取一个素数分析
08-31
主要介绍了hashtable桶数通常会取一个素数分析的相关资料,需要的朋友可以参考下
为什么hashtable桶数通常会取一个素数？如何有效避免hash结果值的碰撞
single6的博客
08-02 3112
为什么一般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 )...
hashTable.zip
12-13
哈希表（HashTable）是一种数据结构，它使用哈希函数将键（Key）映射到一个数组的特定位置，从而实现快速查找、插入和删除操作。哈希表的关键在于哈希函数，它能够将任意大小的键转化为固定大小的索引，这个过程被...
HashTable_Array.rar_哈希函数
09-20
1. **初始容量**：为了减少扩容带来的额外开销，初始容量通常会设置为一个质数，且大于预估的数据量。 2. **扩容策略**：当哈希表的元素数量达到容量的某个比例（如75%）时，需要扩大数组容量，并重新哈希所有元素。...
算法分析：哈希表的大小为何是素数
zhishengqianjun的博客
01-17 9220
1问题分析 2实例分析 1 取模 2 选取数列 3 检验 3结论 1、问题分析 ​ 最近看到了哈希表的问题，网上也看到了一些解释，不过并没有讲的很清楚，正好顺便来探讨一下，如有不足之处，还请指出。 ​ 最简单的哈希算法可以用取模运算，模一般设置为素数，虽然很多书上讲使用素数能够减小冲突，但是并没有讲为什么会减小冲突，下面通过几个实例来说明一下。 2、实例分析
为什么hashtable中桶的数目都是用质数表示
xupeng1644的博客
11-06 3524
在查看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,...
为什么Hashtab的大小通常取远离2^n 的素数
杨博东的博客
03-11 780
举个栗子在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此时最后的结果
哈希 ---《哈希函数》------除数的选取为什么是质数？、《哈希冲突》------解决方法、《闭散列》、《开散列》
lovehang99的博客
10-03 4167
一、哈希概念 顺序结构以及平衡树中，元素关键码与其存储位置之间没有对应的关系，因此在查找一个元素时，必须要经过关键码的多次比较**。顺序查找时间复杂度为O(N)，平衡树中为树的高度，即O(logN )**，搜索的效率取决 于搜索过程中元素的比较次数。 理想的搜索方法：可以不经过任何比较，一次直接从表中得到要搜索的元素。 如果构造一种存储结构，通过 某种函数(hashFunc)使元素的存储位置与它的...
哈希取模余的基底为什么要选择素数？
savorTheFlavor的博客
03-25 1600
蝉的哲学 蝉的生命周期为13年或17年，却很少有14、15或16年，为什么呢？蝉是弱势群体，有很多天敌，选择素数作为其生命周期能最大减少与其天敌们共存的时间，增加自己的存活率，这也是自然选择的结果。 原理分析 从蝉的哲学中获得启示，将哈希取余的基底选择为素数能最大减少哈希冲突情况的发生，使哈希分布更均匀。 假设hash(key) = key % M， 若 M = 2k, 则 key % M = k...
模运算-素数-计算方法
青竹梦
07-28 1143
模运算举例：   6265 % 133   = 62 * 6264 % 133   = 62 * (622)32 % 133   = 62 * 384432 % 133   = 62 * (3844 % 133)32 % 133   = 62 * 12032 % 133   = 62 * 3616 % 133   = 62 * 998 % 133   = 62 * 9
为什么求模运算要用素数（质数）—— 哈希表设计
J.Zz 的博客
11-10 1014
为什么求模运算要用素数（质数）—— 哈希表设计　　在设计用除法来散射的哈希表时，我们都会用数值模哈希表大小，得到的余数来作为ID存入哈希表对应格子中。所有文章都表明要用一个较大的素数来作为哈希表的大小，也就是要模一个较大的素数。但为什么就是要用素数呢？简单分析一下可以看出玄机。　　先看看如果用一个合数8作为哈希表大小，0-30在哈希表中的散射情况：（表1） 　　再来看看用质数7作为哈希表大小，
数据结构：哈希表（线性结构）
weixin_44333294的博客
01-05 1629
（1）哈希表将我们关心的内容转换成索引，直接用一个数组来存储相应的内容，数组本身支持随机访问，可使用O(1)的复杂度来完成各项操作 （2）哈希表中可以存储各种数据类型，对于每种数据类型，都需要一种方法将其转换成索引，将该数据类型转换成索引的函数就是哈希函数 （3）复杂情况下，如键是指身份证号，不能直接用来当作数组的索引；键是字符串，需要设计一个哈希函数将字符串转换成索引；键是浮点数，符合类型等，需要设计一个合理的哈希函数 （4）很难保证每一个键通过哈希函数的转换对应不同的索引，可能产生哈希冲突 关键问题.
使用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、付费专栏及课程。

余额充值