《hello-algo》哈希表 —— 小记随笔
哈希表
哈希表 hash table」,又称「散列表」,它通过建立键 key 与值 value 之间的映射,实现高效的元素查询。具体而言,我们向哈希表中输入一个键 key ,则可以在 (O(1)) 时间内获取对应的值 value 。
除哈希表外,数组和链表也可以实现查询功能,它们的效率对比如表 6-1 所示。
- 添加元素:仅需将元素添加至数组(链表)的尾部即可,使用 (O(1)) 时间。
- 查询元素:由于数组(链表)是乱序的,因此需要遍历其中的所有元素,使用 (O(n)) 时间。
- 删除元素:需要先查询到元素,再从数组(链表)中删除,使用 (O(n)) 时间。
在哈希表中进行增删查改的时间复杂度都是 (O(1)) ,非常高效。
哈希表常用操作
/* 初始化哈希表 */ hmap := make(map[int]string) /* 添加操作 */ // 在哈希表中添加键值对 (key, value) hmap[12836] = "小哈" hmap[15937] = "小啰" hmap[16750] = "小算" hmap[13276] = "小法" hmap[10583] = "小鸭" /* 查询操作 */ // 向哈希表中输入键 key ,得到值 value name := hmap[15937] /* 删除操作 */ // 在哈希表中删除键值对 (key, value) delete(hmap, 10583)
哈希表有三种常用的遍历方式:遍历键值对、遍历键和遍历值。示例代码如下:
/* 遍历哈希表 */ // 遍历键值对 key->value for key, value := range hmap { fmt.Println(key, "->", value) } // 单独遍历键 key for key := range hmap { fmt.Println(key) } // 单独遍历值 value for _, value := range hmap { fmt.Println(value) }
哈希表简单实现
我们先考虑最简单的情况,仅用一个数组来实现哈希表。在哈希表中,我们将数组中的每个空位称为「桶 bucket」,每个桶可存储一个键值对。因此,查询操作就是找到 key 对应的桶,并在桶中获取 value 。
那么,如何基于 key 定位对应的桶呢?这是通过「哈希函数 hash function」实现的。哈希函数的作用是将一个较大的输入空间映射到一个较小的输出空间。在哈希表中,输入空间是所有 key ,输出空间是所有桶(数组索引)。换句话说,输入一个 key ,我们可以通过哈希函数得到该 key 对应的键值对在数组中的存储位置。
输入一个 key ,哈希函数的计算过程分为以下两步。
- 通过某种哈希算法 hash() 计算得到哈希值。
- 将哈希值对桶数量(数组长度)capacity 取模,从而获取该 key 对应的数组索引 index 。
index = hash(key) % capacity
/* 键值对 */ type pair struct { key int val string } /* 基于数组实现的哈希表 */ type arrayHashMap struct { buckets []*pair } /* 初始化哈希表 */ func newArrayHashMap() *arrayHashMap { // 初始化数组,包含 100 个桶 buckets := make([]*pair, 100) return &arrayHashMap{buckets: buckets} } /* 哈希函数 */ func (a *arrayHashMap) hashFunc(key int) int { index := key % 100 return index } /* 查询操作 */ func (a *arrayHashMap) get(key int) string { index := a.hashFunc(key) pair := a.buckets[index] if pair == nil { return "Not Found" } return pair.val } /* 添加操作 */ func (a *arrayHashMap) put(key int, val string) { pair := &pair{key: key, val: val} index := a.hashFunc(key) a.buckets[index] = pair } /* 删除操作 */ func (a *arrayHashMap) remove(key int) { index := a.hashFunc(key) // 置为 nil ,代表删除 a.buckets[index] = nil } /* 获取所有键对 */ func (a *arrayHashMap) pairSet() []*pair { var pairs []*pair for _, pair := range a.buckets { if pair != nil { pairs = append(pairs, pair) } } return pairs } /* 获取所有键 */ func (a *arrayHashMap) keySet() []int { var keys []int for _, pair := range a.buckets { if pair != nil { keys = append(keys, pair.key) } } return keys } /* 获取所有值 */ func (a *arrayHashMap) valueSet() []string { var values []string for _, pair := range a.buckets { if pair != nil { values = append(values, pair.val) } } return values } /* 打印哈希表 */ func (a *arrayHashMap) print() { for _, pair := range a.buckets { if pair != nil { fmt.Println(pair.key, "->", pair.val) } } }
哈希冲突与扩容
从本质上看,哈希函数的作用是将所有 key 构成的输入空间映射到数组所有索引构成的输出空间,而输入空间往往远大于输出空间。因此,理论上一定存在“多个输入对应相同输出”的情况。
容易想到,哈希表容量 (n) 越大,多个 key 被分配到同一个桶中的概率就越低,冲突就越少。因此,我们可以通过扩容哈希表来减少哈希冲突。
类似于数组扩容,哈希表扩容需将所有键值对从原哈希表迁移至新哈希表,非常耗时;并且由于哈希表容量 capacity 改变,我们需要通过哈希函数来重新计算所有键值对的存储位置,这进一步增加了扩容过程的计算开销。为此,编程语言通常会预留足够大的哈希表容量,防止频繁扩容。
「负载因子 load factor」是哈希表的一个重要概念,其定义为哈希表的元素数量除以桶数量,用于衡量哈希冲突的严重程度,也常作为哈希表扩容的触发条件。例如在 Java 中,当负载因子超过 (0.75) 时,系统会将哈希表扩容至原先的 (2) 倍。
哈希冲突
- 改良哈希表数据结构,使得哈希表可以在出现哈希冲突时正常工作。
- 仅在必要时,即当哈希冲突比较严重时,才执行扩容操作。
哈希表的结构改良方法主要包括“链式地址”和“开放寻址”。
链式地址
基于链式地址实现的哈希表的操作方法发生了以下变化。
- 查询元素:输入 key ,经过哈希函数得到桶索引,即可访问链表头节点,然后遍历链表并对比 key 以查找目标键值对。
- 添加元素:首先通过哈希函数访问链表头节点,然后将节点(键值对)添加到链表中。
- 删除元素:根据哈希函数的结果访问链表头部,接着遍历链表以查找目标节点并将其删除。
链式地址存在以下局限性。
- 占用空间增大:链表包含节点指针,它相比数组更加耗费内存空间。
- 查询效率降低:因为需要线性遍历链表来查找对应元素。
以下代码给出了链式地址哈希表的简单实现,需要注意两点。
- 使用列表(动态数组)代替链表,从而简化代码。在这种设定下,哈希表(数组)包含多个桶,每个桶都是一个列表。
- 以下实现包含哈希表扩容方法。当负载因子超过 (\frac{2}{3}) 时,我们将哈希表扩容至原先的 (2) 倍。
/* 链式地址哈希表 */ type hashMapChaining struct { size int // 键值对数量 capacity int // 哈希表容量 loadThres float64 // 触发扩容的负载因子阈值 extendRatio int // 扩容倍数 buckets [][]pair // 桶数组 } /* 构造方法 */ func newHashMapChaining() *hashMapChaining { buckets := make([][]pair, 4) for i := 0; i < 4; i++ { buckets[i] = make([]pair, 0) } return &hashMapChaining{ size: 0, capacity: 4, loadThres: 2.0 / 3.0, extendRatio: 2, buckets: buckets, } } /* 哈希函数 */ func (m *hashMapChaining) hashFunc(key int) int { return key % m.capacity } /* 负载因子 */ func (m *hashMapChaining) loadFactor() float64 { return float64(m.size) / float64(m.capacity) } /* 查询操作 */ func (m *hashMapChaining) get(key int) string { idx := m.hashFunc(key) bucket := m.buckets[idx] // 遍历桶,若找到 key ,则返回对应 val for _, p := range bucket { if p.key == key { return p.val } } // 若未找到 key ,则返回空字符串 return "" } /* 添加操作 */ func (m *hashMapChaining) put(key int, val string) { // 当负载因子超过阈值时,执行扩容 if m.loadFactor() > m.loadThres { m.extend() } idx := m.hashFunc(key) // 遍历桶,若遇到指定 key ,则更新对应 val 并返回 for i := range m.buckets[idx] { if m.buckets[idx][i].key == key { m.buckets[idx][i].val = val return } } // 若无该 key ,则将键值对添加至尾部 p := pair{ key: key, val: val, } m.buckets[idx] = append(m.buckets[idx], p) m.size += 1 } /* 删除操作 */ func (m *hashMapChaining) remove(key int) { idx := m.hashFunc(key) // 遍历桶,从中删除键值对 for i, p := range m.buckets[idx] { if p.key == key { // 切片删除 m.buckets[idx] = append(m.buckets[idx][:i], m.buckets[idx][i+1:]...) m.size -= 1 break } } } /* 扩容哈希表 */ func (m *hashMapChaining) extend() { // 暂存原哈希表 tmpBuckets := make([][]pair, len(m.buckets)) for i := 0; i < len(m.buckets); i++ { tmpBuckets[i] = make([]pair, len(m.buckets[i])) copy(tmpBuckets[i], m.buckets[i]) } // 初始化扩容后的新哈希表 m.capacity *= m.extendRatio m.buckets = make([][]pair, m.capacity) for i := 0; i < m.capacity; i++ { m.buckets[i] = make([]pair, 0) } m.size = 0 // 将键值对从原哈希表搬运至新哈希表 for _, bucket := range tmpBuckets { for _, p := range bucket { m.put(p.key, p.val) } } } /* 打印哈希表 */ func (m *hashMapChaining) print() { var builder strings.Builder for _, bucket := range m.buckets { builder.WriteString("[") for _, p := range bucket { builder.WriteString(strconv.Itoa(p.key) + " -> " + p.val + " ") } builder.WriteString("]") fmt.Println(builder.String()) builder.Reset() } }
开放寻址
「开放寻址 open addressing」不引入额外的数据结构,而是通过“多次探测”来处理哈希冲突,探测方式主要包括线性探测、平方探测和多次哈希等。
线性探测
线性探测采用固定步长的线性搜索来进行探测,其操作方法与普通哈希表有所不同。
- 插入元素:通过哈希函数计算桶索引,若发现桶内已有元素,则从冲突位置向后线性遍历(步长通常为 (1) ),直至找到空桶,将元素插入其中。
- 查找元素:若发现哈希冲突,则使用相同步长向后进行线性遍历,直到找到对应元素,返回 value 即可;如果遇到空桶,说明目标元素不在哈希表中,返回 None 。
然而,线性探测容易产生“聚集现象”。具体来说,数组中连续被占用的位置越长,这些连续位置发生哈希冲突的可能性越大,从而进一步促使该位置的聚堆生长,形成恶性循环,最终导致增删查改操作效率劣化。
值得注意的是,我们不能在开放寻址哈希表中直接删除元素。这是因为删除元素会在数组内产生一个空桶 None ,而当查询元素时,线性探测到该空桶就会返回,因此在该空桶之下的元素都无法再被访问到,程序可能误判这些元素不存在,如图 6-7 所示。
为了解决该问题,我们可以采用「懒删除 lazy deletion」机制:它不直接从哈希表中移除元素,而是利用一个常量 TOMBSTONE 来标记这个桶。在该机制下,None 和 TOMBSTONE 都代表空桶,都可以放置键值对。但不同的是,线性探测到 TOMBSTONE 时应该继续遍历,因为其之下可能还存在键值对。
然而,懒删除可能会加速哈希表的性能退化。这是因为每次删除操作都会产生一个删除标记,随着 TOMBSTONE 的增加,搜索时间也会增加,因为线性探测可能需要跳过多个 TOMBSTONE 才能找到目标元素。
为此,考虑在线性探测中记录遇到的首个 TOMBSTONE 的索引,并将搜索到的目标元素与该 TOMBSTONE 交换位置。这样做的好处是当每次查询或添加元素时,元素会被移动至距离理想位置(探测起始点)更近的桶,从而优化查询效率。
以下代码实现了一个包含懒删除的开放寻址(线性探测)哈希表。为了更加充分地使用哈希表的空间,我们将哈希表看作一个“环形数组”,当越过数组尾部时,回到头部继续遍历。
/* 开放寻址哈希表 */ type hashMapOpenAddressing struct { size int // 键值对数量 capacity int // 哈希表容量 loadThres float64 // 触发扩容的负载因子阈值 extendRatio int // 扩容倍数 buckets []pair // 桶数组 removed pair // 删除标记 } /* 构造方法 */ func newHashMapOpenAddressing() *hashMapOpenAddressing { buckets := make([]pair, 4) return &hashMapOpenAddressing{ size: 0, capacity: 4, loadThres: 2.0 / 3.0, extendRatio: 2, buckets: buckets, removed: pair{ key: -1, val: "-1", }, } } /* 哈希函数 */ func (m *hashMapOpenAddressing) hashFunc(key int) int { return key % m.capacity } /* 负载因子 */ func (m *hashMapOpenAddressing) loadFactor() float64 { return float64(m.size) / float64(m.capacity) } /* 查询操作 */ func (m *hashMapOpenAddressing) get(key int) string { idx := m.hashFunc(key) // 线性探测,从 index 开始向后遍历 for i := 0; i < m.capacity; i++ { // 计算桶索引,越过尾部则返回头部 j := (idx + i) % m.capacity // 若遇到空桶,说明无此 key ,则返回 null if m.buckets[j] == (pair{}) { return "" } // 若遇到指定 key ,则返回对应 val if m.buckets[j].key == key && m.buckets[j] != m.removed { return m.buckets[j].val } } // 若未找到 key ,则返回空字符串 return "" } /* 添加操作 */ func (m *hashMapOpenAddressing) put(key int, val string) { // 当负载因子超过阈值时,执行扩容 if m.loadFactor() > m.loadThres { m.extend() } idx := m.hashFunc(key) // 线性探测,从 index 开始向后遍历 for i := 0; i < m.capacity; i++ { // 计算桶索引,越过尾部则返回头部 j := (idx + i) % m.capacity // 若遇到空桶、或带有删除标记的桶,则将键值对放入该桶 if m.buckets[j] == (pair{}) || m.buckets[j] == m.removed { m.buckets[j] = pair{ key: key, val: val, } m.size += 1 return } // 若遇到指定 key ,则更新对应 val if m.buckets[j].key == key { m.buckets[j].val = val return } } } /* 删除操作 */ func (m *hashMapOpenAddressing) remove(key int) { idx := m.hashFunc(key) // 遍历桶,从中删除键值对 // 线性探测,从 index 开始向后遍历 for i := 0; i < m.capacity; i++ { // 计算桶索引,越过尾部则返回头部 j := (idx + i) % m.capacity // 若遇到空桶,说明无此 key ,则直接返回 if m.buckets[j] == (pair{}) { return } // 若遇到指定 key ,则标记删除并返回 if m.buckets[j].key == key { m.buckets[j] = m.removed m.size -= 1 } } } /* 扩容哈希表 */ func (m *hashMapOpenAddressing) extend() { // 暂存原哈希表 tmpBuckets := make([]pair, len(m.buckets)) copy(tmpBuckets, m.buckets) // 初始化扩容后的新哈希表 m.capacity *= m.extendRatio m.buckets = make([]pair, m.capacity) m.size = 0 // 将键值对从原哈希表搬运至新哈希表 for _, p := range tmpBuckets { if p != (pair{}) && p != m.removed { m.put(p.key, p.val) } } } /* 打印哈希表 */ func (m *hashMapOpenAddressing) print() { for _, p := range m.buckets { if p != (pair{}) { fmt.Println(strconv.Itoa(p.key) + " -> " + p.val) } else { fmt.Println("nil") } } }
平方探测
平方探测与线性探测类似,都是开放寻址的常见策略之一。当发生冲突时,平方探测不是简单地跳过一个固定的步数,而是跳过“探测次数的平方”的步数,即 (1, 4, 9, \dots) 步。
平方探测主要具有以下优势。
-
平方探测通过跳过探测次数平方的距离,试图缓解线性探测的聚集效应。
-
平方探测会跳过更大的距离来寻找空位置,有助于数据分布得更加均匀。
然而,平方探测并不是完美的。 -
仍然存在聚集现象,即某些位置比其他位置更容易被占用。
-
由于平方的增长,平方探测可能不会探测整个哈希表,这意味着即使哈希表中有空桶,平方探测也可能无法访问到它。
多次哈希
顾名思义,多次哈希方法使用多个哈希函数 (f_1(x))、(f_2(x))、(f_3(x))、(\dots) 进行探测。
- 插入元素:若哈希函数 (f_1(x)) 出现冲突,则尝试 (f_2(x)) ,以此类推,直到找到空位后插入元素。
- 查找元素:在相同的哈希函数顺序下进行查找,直到找到目标元素时返回;若遇到空位或已尝试所有哈希函数,说明哈希表中不存在该元素,则返回 None 。
与线性探测相比,多次哈希方法不易产生聚集,但多个哈希函数会带来额外的计算量。
哈希算法
哈希算法的目标
为了实现“既快又稳”的哈希表数据结构,哈希算法应具备以下特点。
- 确定性:对于相同的输入,哈希算法应始终产生相同的输出。这样才能确保哈希表是可靠的。
- 效率高:计算哈希值的过程应该足够快。计算开销越小,哈希表的实用性越高。
- 均匀分布:哈希算法应使得键值对均匀分布在哈希表中。分布越均匀,哈希冲突的概率就越低。
实际上,哈希算法除了可以用于实现哈希表,还广泛应用于其他领域中。
- 密码存储:为了保护用户密码的安全,系统通常不会直接存储用户的明文密码,而是存储密码的哈希值。当用户输入密码时,系统会对输入的密码计算哈希值,然后与存储的哈希值进行比较。如果两者匹配,那么密码就被视为正确。
- 数据完整性检查:数据发送方可以计算数据的哈希值并将其一同发送;接收方可以重新计算接收到的数据的哈希值,并与接收到的哈希值进行比较。如果两者匹配,那么数据就被视为完整。
对于密码学的相关应用,为了防止从哈希值推导出原始密码等逆向工程,哈希算法需要具备更高等级的安全特性。
- 单向性:无法通过哈希值反推出关于输入数据的任何信息。
- 抗碰撞性:应当极难找到两个不同的输入,使得它们的哈希值相同。
- 雪崩效应:输入的微小变化应当导致输出的显著且不可预测的变化。
哈希算法的设计
哈希算法的设计是一个需要考虑许多因素的复杂问题。然而对于某些要求不高的场景,我们也能设计一些简单的哈希算法。
- 加法哈希:对输入的每个字符的 ASCII 码进行相加,将得到的总和作为哈希值。
- 乘法哈希:利用乘法的不相关性,每轮乘以一个常数,将各个字符的 ASCII 码累积到哈希值中。
- 异或哈希:将输入数据的每个元素通过异或操作累积到一个哈希值中。
- 旋转哈希:将每个字符的 ASCII 码累积到一个哈希值中,每次累积之前都会对哈希值进行旋转操作。
/* 加法哈希 */ func addHash(key string) int { var hash int64 var modulus int64 modulus = 1000000007 for _, b := range []byte(key) { hash = (hash + int64(b)) % modulus } return int(hash) } /* 乘法哈希 */ func mulHash(key string) int { var hash int64 var modulus int64 modulus = 1000000007 for _, b := range []byte(key) { hash = (31*hash + int64(b)) % modulus } return int(hash) } /* 异或哈希 */ func xorHash(key string) int { hash := 0 modulus := 1000000007 for _, b := range []byte(key) { fmt.Println(int(b)) hash ^= int(b) hash = (31*hash + int(b)) % modulus } return hash & modulus } /* 旋转哈希 */ func rotHash(key string) int { var hash int64 var modulus int64 modulus = 1000000007 for _, b := range []byte(key) { hash = ((hash << 4) ^ (hash >> 28) ^ int64(b)) % modulus } return int(hash) }
观察发现,每种哈希算法的最后一步都是对大质数 (1000000007) 取模,以确保哈希值在合适的范围内。值得思考的是,为什么要强调对质数取模,或者说对合数取模的弊端是什么?这是一个有趣的问题。
先抛出结论:使用大质数作为模数,可以最大化地保证哈希值的均匀分布。因为质数不与其他数字存在公约数,可以减少因取模操作而产生的周期性模式,从而避免哈希冲突。
值得说明的是,如果能够保证 key 是随机均匀分布的,那么选择质数或者合数作为模数都可以,它们都能输出均匀分布的哈希值。而当 key 的分布存在某种周期性时,对合数取模更容易出现聚集现象。
常见哈希算法
在实际中,我们通常会用一些标准哈希算法,例如 MD5、SHA-1、SHA-2 和 SHA-3 等。它们可以将任意长度的输入数据映射到恒定长度的哈希值。
- MD5 和 SHA-1 已多次被成功攻击,因此它们被各类安全应用弃用。
- SHA-2 系列中的 SHA-256 是最安全的哈希算法之一,仍未出现成功的攻击案例,因此常用在各类安全应用与协议中。
- SHA-3 相较 SHA-2 的实现开销更低、计算效率更高,但目前使用覆盖度不如 SHA-2 系列。
数据结构的哈希值
我们知道,哈希表的 key 可以是整数、小数或字符串等数据类型。编程语言通常会为这些数据类型提供内置的哈希算法,用于计算哈希表中的桶索引。以 Python 为例,我们可以调用 hash() 函数来计算各种数据类型的哈希值。
- 整数和布尔量的哈希值就是其本身。
- 浮点数和字符串的哈希值计算较为复杂,有兴趣的读者请自行学习。
- 元组的哈希值是对其中每一个元素进行哈希,然后将这些哈希值组合起来,得到单一的哈希值。
- 对象的哈希值基于其内存地址生成。通过重写对象的哈希方法,可实现基于内容生成哈希值。
本文作者:Blue Mountain
本文链接:https://www.cnblogs.com/BlueMountain-HaggenDazs/p/18023542
版权声明:本作品采用知识共享署名-非商业性使用-禁止演绎 2.5 中国大陆许可协议进行许可。
【推荐】编程新体验,更懂你的AI,立即体验豆包MarsCode编程助手
【推荐】凌霞软件回馈社区,博客园 & 1Panel & Halo 联合会员上线
【推荐】抖音旗下AI助手豆包,你的智能百科全书,全免费不限次数
【推荐】博客园社区专享云产品让利特惠,阿里云新客6.5折上折
【推荐】轻量又高性能的 SSH 工具 IShell:AI 加持,快人一步