数据结构与算法-哈希表(HashTable)-优快云博客

哈希表的基本概念

哈希表（HashTable）是一种通过键（Key）直接访问值（Value）的数据结构。其核心思想是通过哈希函数将键映射到存储位置（桶或槽），从而实现高效的插入、删除和查找操作。理想情况下，哈希表的操作时间复杂度为O(1)。

哈希表的关键组成部分：

哈希函数：将键转换为数组索引。
冲突处理：解决不同键映射到同一索引的问题（如链地址法、开放地址法）。

哈希函数的设计

哈希函数需满足均匀分布性，以减少冲突。以下是一个简单示例：

def hash_function(key, size):
    return hash(key) % size

对于字符串键，常用多项式滚动哈希：

def string_hash(key, size):
    hash_val = 0
    for char in key:
        hash_val = (hash_val * 31 + ord(char)) % size
    return hash_val

冲突处理方法

链地址法（Separate Chaining）

每个桶存储一个链表，冲突的键值对添加到链表中。

class HashTable:
    def __init__(self, size):
        self.size = size
        self.table = [[] for _ in range(size)]
    
    def insert(self, key, value):
        index = hash_function(key, self.size)
        for item in self.table[index]:
            if item[0] == key:
                item[1] = value
                return
        self.table[index].append([key, value])
    
    def get(self, key):
        index = hash_function(key, self.size)
        for item in self.table[index]:
            if item[0] == key:
                return item[1]
        raise KeyError("Key not found")

开放地址法（Open Addressing）

冲突时探测下一个可用位置（如线性探测、二次探测）。

class OpenAddressingHashTable:
    def __init__(self, size):
        self.size = size
        self.table = [None] * size
    
    def insert(self, key, value):
        index = hash_function(key, self.size)
        while self.table[index] is not None:
            if self.table[index][0] == key:
                self.table[index] = (key, value)
                return
            index = (index + 1) % self.size
        self.table[index] = (key, value)
    
    def get(self, key):
        index = hash_function(key, self.size)
        while self.table[index] is not None:
            if self.table[index][0] == key:
                return self.table[index][1]
            index = (index + 1) % self.size
        raise KeyError("Key not found")

动态扩容与负载因子

当负载因子（元素数量/桶数量）超过阈值（如0.75）时，需扩容并重新哈希。

class DynamicHashTable:
    def __init__(self, initial_size=8, load_factor=0.75):
        self.size = initial_size
        self.load_factor = load_factor
        self.count = 0
        self.table = [[] for _ in range(initial_size)]
    
    def resize(self):
        new_size = self.size * 2
        new_table = [[] for _ in range(new_size)]
        for bucket in self.table:
            for key, value in bucket:
                index = hash_function(key, new_size)
                new_table[index].append([key, value])
        self.table = new_table
        self.size = new_size
    
    def insert(self, key, value):
        if self.count / self.size > self.load_factor:
            self.resize()
        index = hash_function(key, self.size)
        for item in self.table[index]:
            if item[0] == key:
                item[1] = value
                return
        self.table[index].append([key, value])
        self.count += 1

实际应用示例

统计单词频率：

def word_frequency(text):
    freq = {}
    for word in text.split():
        freq[word] = freq.get(word, 0) + 1
    return freq

性能分析

平均情况：插入、删除、查找均为O(1)。
最坏情况：所有键冲突，退化为链表（O(n)）。
优化方向：设计优质哈希函数、合理负载因子、高效冲突处理。

哈希表在数据库索引、缓存（如Redis）、语言字典等场景广泛应用。