C++链式哈希表实现与优化

template <typename K, typename V>
struct HashNode {
    K key;
    V value;
    HashNode* next;  // 链表指针
    
    HashNode(const K& k, const V& v) 
        : key(k), value(v), next(nullptr) {}
};

template <typename K, typename V> 
class HashMap {
private:
    std::vector<HashNode<K,V>*> table;  // 桶数组
    size_t capacity;                    // 桶数量
    size_t size;                        // 元素总数
    
    // 哈希函数（后续详解）
    size_t hashFunction(const K& key) const;
    
public:
    // 构造函数/析构函数
    HashMap(size_t cap = 16);
    ~HashMap();
    
    // 核心操作接口
    void insert(const K& key, const V& value);
    bool get(const K& key, V& value) const;
    bool remove(const K& key);
};

size_t hashFunction(const K& key) const {
    return std::hash<K>{}(key) % capacity;
}

namespace std {
    template<>
    struct hash<MyClass> {
        size_t operator()(const MyClass& obj) const {
            // 自定义哈希逻辑
        }
    };
}

void insert(const K& key, const V& value) {
    size_t index = hashFunction(key);
    HashNode<K,V>* node = table[index];
    
    // 遍历链表查找key
    while (node) {
        if (node->key == key) {
            node->value = value; // 更新值
            return;
        }
        node = node->next;
    }
    
    // 新建节点并插入链表头部
    HashNode<K,V>* newNode = new HashNode<K,V>(key, value);
    newNode->next = table[index];
    table[index] = newNode;
    size++;
    
    // 检查扩容（后续讲解）
    if (loadFactor() > 0.75) {
        rehash();
    }
}

bool get(const K& key, V& value) const {
    size_t index = hashFunction(key);
    HashNode<K,V>* node = table[index];
    
    while (node) {
        if (node->key == key) {
            value = node->value;
            return true;
        }
        node = node->next;
    }
    return false;
}

bool remove(const K& key) {
    size_t index = hashFunction(key);
    HashNode<K,V>* node = table[index];
    HashNode<K,V>* prev = nullptr;
    
    while (node) {
        if (node->key == key) {
            if (prev) {
                prev->next = node->next;
            } else {
                table[index] = node->next;
            }
            delete node;
            size--;
            return true;
        }
        prev = node;
        node = node->next;
    }
    return false;
}

double loadFactor() const {
    return static_cast<double>(size) / capacity;
}

void rehash() {
    size_t newCap = capacity * 2;
    std::vector<HashNode<K,V>*> newTable(newCap);
    
    // 重新哈希所有元素
    for (size_t i = 0; i < capacity; ++i) {
        HashNode<K,V>* node = table[i];
        while (node) {
            HashNode<K,V>* next = node->next;
            size_t newIndex = std::hash<K>{}(node->key) % newCap;
            
            node->next = newTable[newIndex];
            newTable[newIndex] = node;
            
            node = next;
        }
    }
    
    table = std::move(newTable);
    capacity = newCap;
}

void testHashMap() {
    HashMap<std::string, int> map;
    
    // 测试插入与查找
    map.insert("apple", 5);
    map.insert("banana", 3);
    
    int value;
    assert(map.get("apple", value) && value == 5);
    
    // 测试更新
    map.insert("apple", 7);
    assert(map.get("apple", value) && value == 7);
    
    // 测试删除
    assert(map.remove("banana"));
    assert(!map.get("banana", value));
    
    // 测试扩容
    for (int i = 0; i < 100; ++i) {
        map.insert("key_" + std::to_string(i), i);
    }
    assert(map.get("key_50", value) && value == 50);
}

~HashMap() {
    for (size_t i = 0; i < capacity; ++i) {
        HashNode<K,V>* node = table[i];
        while (node) {
            HashNode<K,V>* next = node->next;
            delete node;
            node = next;
        }
    }
}

void benchmark() {
    HashMap<int, int> map;
    auto start = std::chrono::high_resolution_clock::now();
    
    // 插入测试
    for (int i = 0; i < 100000; ++i) {
        map.insert(i, i*2);
    }
    
    // 查找测试
    int value;
    for (int i = 0; i < 100000; i += 1000) {
        map.get(i, value);
    }
    
    auto end = std::chrono::high_resolution_clock::now();
    std::cout << "Time: " 
              << std::chrono::duration_cast<std::chrono::milliseconds>(end-start).count()
              << "ms\n";
}