C++哈希表实现：从原理到自定义unordered_map/unordered_set

1. 为什么需要自己实现哈希表容器？

在C++标准库中，unordered_map和unordered_set是非常实用的关联容器，它们基于哈希表实现，提供了O(1)时间复杂度的查找操作。但很多开发者在使用这些容器时，往往只是停留在表面调用API的层面，对其内部实现机制知之甚少。

自己动手实现简化版的myunordered_map和myunordered_set有几个显著好处：

首先，这能让我们深入理解哈希表这种数据结构的工作原理。哈希表的核心在于哈希函数的设计、冲突处理策略的选择以及扩容机制等。通过亲手实现，我们会遇到并解决各种实际问题，比如如何设计一个好的哈希函数、如何处理哈希冲突、何时触发扩容等。

其次，标准库的unordered_map和unordered_set为了通用性和性能做了大量优化，代码非常复杂。我们自己实现简化版本，可以专注于核心逻辑，避免被各种边缘情况和优化技巧分散注意力。这种聚焦核心的学习方式往往更高效。

再者，在实际项目中，我们有时需要定制化的哈希表实现。比如某些特殊场景下，标准库的实现可能不是最优选择。有了自己实现的经验，我们就能根据具体需求调整实现策略。

2. 哈希表基础结构设计

2.1 哈希表的核心组件

一个基本的哈希表实现需要以下几个核心组件：

哈希函数：负责将键转换为数组索引。一个好的哈希函数应该尽可能均匀地分布键，减少冲突。对于内置类型如int、string等，C++标准库已经提供了默认的哈希函数。对于自定义类型，我们需要特化std::hash或提供自定义哈希函数。

桶数组：存储数据的底层结构，通常是一个vector。每个桶可以是一个链表（分离链接法）或直接存储元素（开放寻址法）。我们这里采用更常见的分离链接法。

节点结构：每个键值对会被封装为一个节点。对于unordered_map，节点需要存储key和value；对于unordered_set，只需要存储key。

cpp复制template <typename T>
struct HashNode {
    T data;
    HashNode* next;
    
    HashNode(const T& d) : data(d), next(nullptr) {}
};

// unordered_map的特化版本
template <typename K, typename V>
struct HashNode<std::pair<K, V>> {
    std::pair<K, V> data;
    HashNode* next;
    
    HashNode(const K& k, const V& v) : data(std::make_pair(k, v)), next(nullptr) {}
};

2.2 模板设计

为了同时支持unordered_map和unordered_set，我们可以设计一个通用的HashTable基类，然后派生出具体的容器类。这样可以最大化代码复用。

cpp复制template <typename T, typename Hash = std::hash<T>>
class HashTable {
protected:
    std::vector<HashNode<T>*> buckets;
    size_t element_count = 0;
    Hash hasher;
    
    // 扩容阈值，当元素数量超过bucket_size * max_load_factor时触发扩容
    float max_load_factor = 1.0f;
    
    // 其他辅助方法...
};

3. 关键操作实现细节

3.1 插入操作

插入操作需要考虑以下几种情况：

1. 计算key的哈希值，找到对应的桶
2. 如果桶为空，直接创建新节点插入
3. 如果桶不为空，需要遍历链表检查key是否已存在
4. 如果存在，根据容器类型决定是否更新值（map更新，set不更新）
5. 如果不存在，将新节点插入链表头部
6. 插入后检查是否需要扩容

cpp复制bool insert(const T& value) {
    // 检查是否需要扩容
    if (need_rehash()) {
        rehash(buckets.size() * 2 + 1);
    }
    
    size_t bucket_idx = hasher(value) % buckets.size();
    HashNode<T>* current = buckets[bucket_idx];
    
    // 检查是否已存在
    while (current != nullptr) {
        if (equal(current->data, value)) {
            // 对于set，已存在则返回false
            // 对于map，可能需要更新value
            return false;
        }
        current = current->next;
    }
    
    // 插入新节点到链表头部
    HashNode<T>* new_node = new HashNode<T>(value);
    new_node->next = buckets[bucket_idx];
    buckets[bucket_idx] = new_node;
    element_count++;
    
    return true;
}

3.2 查找操作

查找操作相对简单：

1. 计算key的哈希值，找到对应桶
2. 遍历桶中的链表，比较每个节点的key
3. 找到返回节点指针，否则返回nullptr

cpp复制HashNode<T>* find(const T& key) const {
    size_t bucket_idx = hasher(key) % buckets.size();
    HashNode<T>* current = buckets[bucket_idx];
    
    while (current != nullptr) {
        if (equal(current->data, key)) {
            return current;
        }
        current = current->next;
    }
    
    return nullptr;
}

3.3 删除操作

删除操作需要注意内存管理和链表指针的更新：

1. 找到key对应的桶
2. 遍历链表，找到要删除的节点
3. 维护前驱节点的next指针
4. 释放被删除节点的内存

cpp复制bool erase(const T& key) {
    size_t bucket_idx = hasher(key) % buckets.size();
    HashNode<T>* current = buckets[bucket_idx];
    HashNode<T>* prev = nullptr;
    
    while (current != nullptr) {
        if (equal(current->data, key)) {
            if (prev == nullptr) {
                // 删除的是链表头节点
                buckets[bucket_idx] = current->next;
            } else {
                prev->next = current->next;
            }
            
            delete current;
            element_count--;
            return true;
        }
        
        prev = current;
        current = current->next;
    }
    
    return false;
}

4. 扩容与重哈希机制

4.1 何时需要扩容

哈希表的性能很大程度上取决于负载因子（元素数量/桶数量）。当负载因子过高时，冲突概率增加，性能下降。我们需要在负载因子超过max_load_factor时触发扩容。

cpp复制bool need_rehash() const {
    return float(element_count) / buckets.size() > max_load_factor;
}

4.2 重哈希实现

重哈希是一个相对昂贵的操作，需要：

1. 分配新的更大的桶数组
2. 遍历所有现有元素
3. 对每个元素重新计算哈希值，插入到新桶中
4. 释放旧桶的内存

cpp复制void rehash(size_t new_bucket_count) {
    if (new_bucket_count <= buckets.size()) return;
    
    std::vector<HashNode<T>*> new_buckets(new_bucket_count, nullptr);
    
    for (auto& head : buckets) {
        HashNode<T>* current = head;
        while (current != nullptr) {
            HashNode<T>* next = current->next;
            
            // 重新计算哈希值
            size_t new_bucket_idx = hasher(current->data) % new_bucket_count;
            
            // 插入到新桶的链表头部
            current->next = new_buckets[new_bucket_idx];
            new_buckets[new_bucket_idx] = current;
            
            current = next;
        }
    }
    
    buckets.swap(new_buckets);
}

5. 封装unordered_map和unordered_set

5.1 myunordered_set实现

基于HashTable，我们可以很容易实现unordered_set：

cpp复制template <typename Key, typename Hash = std::hash<Key>>
class myunordered_set : public HashTable<Key, Hash> {
public:
    using Base = HashTable<Key, Hash>;
    
    // 插入元素
    std::pair<iterator, bool> insert(const Key& key) {
        bool inserted = Base::insert(key);
        return {iterator(/*...*/), inserted};
    }
    
    // 查找元素
    iterator find(const Key& key) const {
        auto node = Base::find(key);
        return node ? iterator(/*...*/) : end();
    }
    
    // 迭代器相关实现...
};

5.2 myunordered_map实现

unordered_map需要处理键值对，实现稍微复杂一些：

cpp复制template <typename Key, typename Value, typename Hash = std::hash<Key>>
class myunordered_map : public HashTable<std::pair<Key, Value>, Hash> {
public:
    using Base = HashTable<std::pair<Key, Value>, Hash>;
    
    // 重载operator[]，提供类似标准库的访问方式
    Value& operator[](const Key& key) {
        auto node = Base::find(std::make_pair(key, Value()));
        if (node == nullptr) {
            Base::insert(std::make_pair(key, Value()));
            node = Base::find(std::make_pair(key, Value()));
        }
        return node->data.second;
    }
    
    // 插入键值对
    std::pair<iterator, bool> insert(const std::pair<Key, Value>& kv) {
        bool inserted = Base::insert(kv);
        return {iterator(/*...*/), inserted};
    }
    
    // 其他map特有接口...
};

6. 性能优化与注意事项

6.1 哈希函数选择

哈希函数的质量直接影响哈希表的性能。对于内置类型，使用std::hash通常足够。对于自定义类型，我们需要提供良好的哈希函数：

cpp复制struct MyKeyHash {
    size_t operator()(const MyKey& k) const {
        // 结合各字段的哈希值
        size_t h1 = std::hash<int>{}(k.field1);
        size_t h2 = std::hash<std::string>{}(k.field2);
        return h1 ^ (h2 << 1);
    }
};

6.2 负载因子调整

负载因子的选择需要在内存占用和性能之间权衡：

• 较小的max_load_factor（如0.7）可以减少冲突，提高查找速度，但会增加内存使用
• 较大的max_load_factor（如1.5）可以节省内存，但会增加冲突概率

6.3 迭代器失效问题

哈希表的某些操作（如rehash）会导致所有迭代器失效。这与标准库的行为一致，需要在文档中明确说明。

6.4 线程安全考虑

我们的基本实现不是线程安全的。如果需要在多线程环境中使用，可以考虑：

1. 为整个哈希表加一个大锁（简单但性能差）
2. 为每个桶加锁（细粒度锁，实现复杂）
3. 使用读写锁优化读多写少的场景

7. 测试与验证

实现完成后，我们需要编写全面的测试用例来验证容器的正确性：

cpp复制void test_myunordered_map() {
    myunordered_map<std::string, int> map;
    
    // 测试插入和查找
    map.insert({"one", 1});
    assert(map["one"] == 1);
    
    // 测试operator[]
    map["two"] = 2;
    assert(map["two"] == 2);
    
    // 测试扩容
    for (int i = 0; i < 1000; ++i) {
        map[std::to_string(i)] = i;
    }
    assert(map.size() == 1002);
    
    // 测试删除
    map.erase("one");
    assert(map.find("one") == map.end());
}

void test_myunordered_set() {
    myunordered_set<int> set;
    
    // 测试插入和查找
    set.insert(1);
    assert(set.find(1) != set.end());
    
    // 测试重复插入
    auto res = set.insert(1);
    assert(!res.second);
    
    // 测试扩容
    for (int i = 0; i < 1000; ++i) {
        set.insert(i);
    }
    assert(set.size() == 1000);
}

通过自己实现简化版的unordered_map和unordered_set，我们不仅深入理解了哈希表的工作原理，还掌握了如何设计通用的容器类模板。这种底层实现的经验对于理解标准库的设计思路和编写高性能代码非常有帮助。