哈希表：高效存储与查找的核心原理

哈希表的基本概念

哈希表（Hash Table）是一种基于键值对（Key-Value）存储的数据结构，通过哈希函数将键（Key）映射到表中的特定位置（桶或槽），从而实现高效的数据插入、删除和查找操作。理想情况下，哈希表的操作时间复杂度为 $O(1)$ 。

哈希函数的设计

哈希函数是哈希表的核心，其作用是将任意大小的数据映射到固定大小的哈希值。设计时需满足以下条件：

一致性：相同的键必须生成相同的哈希值。
均匀性：哈希值应尽可能均匀分布，减少冲突。
高效性：计算速度快。

常见的哈希函数包括：

除法取余法： $h(key) = key \\mod p$ （ $p$ 通常为质数）。
乘法取余法： $h(key) = \\lfloor m \\cdot (key \\cdot A \\mod 1) \\rfloor$ （ $A$ 为常数， $0 \< A \< 1$ ）。
MD5/SHA：适用于加密场景，但计算开销较大。

冲突解决方法

当不同键映射到同一位置时，需通过冲突解决策略处理：

1. 开放定址法

线性探测：冲突时顺序查找下一个空槽，公式为 $h_i(key) = (h(key) + i) \\mod m$ 。
平方探测：避免聚集现象，公式为 $h_i(key) = (h(key) + i\^2) \\mod m$ 。
双重哈希：使用第二个哈希函数，公式为 $h_i(key) = (h_1(key) + i \\cdot h_2(key)) \\mod m$ 。

2. 链地址法

每个桶存储一个链表（或其他数据结构），冲突的键值对直接添加到链表中。Java 的 HashMap 即采用此方法。

哈希表的性能分析

负载因子： $\\alpha = \\frac{n}{m}$ （ $n$ 为元素数量， $m$ 为桶数量）。负载因子过高会导致冲突概率增加，通常需动态扩容（如 $\\alpha \> 0.75$ 时）。
时间复杂度：理想情况下为 $O(1)$ ，最坏情况下（全冲突）退化为 $O(n)$ 。

动态扩容与重哈希

当负载因子超过阈值时，哈希表需扩容（通常翻倍），并重新计算所有键的哈希值（重哈希）。例如：

python 复制代码

def resize(new_capacity):
    new_table = [None] * new_capacity
    for bucket in old_table:
        for key, value in bucket:
            new_hash = hash_function(key) % new_capacity
            new_table[new_hash].append((key, value))
    return new_table

哈希表的应用场景

字典实现 ：如 Python 的 dict、Java 的 HashMap。
缓存系统：Redis 的键值存储。
去重操作：快速判断元素是否存在（如 Bloom Filter）。

代码示例（Python 实现链地址法）

python 复制代码

class HashTable:
    def __init__(self, size=10):
        self.size = size
        self.table = [[] for _ in range(size)]

    def _hash(self, key):
        return hash(key) % self.size

    def insert(self, key, value):
        hash_key = self._hash(key)
        for i, (k, v) in enumerate(self.table[hash_key]):
            if k == key:
                self.table[hash_key][i] = (key, value)
                return
        self.table[hash_key].append((key, value))

    def get(self, key):
        hash_key = self._hash(key)
        for k, v in self.table[hash_key]:
            if k == key:
                return v
        raise KeyError(key)