C++经典的数据结构与算法之哈希表详解(Hash Table)

// 取模哈希（最常用）
int hashFunction(int key, int tableSize) {
    return key % tableSize; // 确保索引在数组范围内
}
// 字符串哈希（将字符ASCII值组合）
int hashString(const string& key, int tableSize) {
    int hash = 0;
    for (char c : key) {
        hash = (hash * 31 + c) % tableSize; // 31是质数，减少冲突
    }
    return hash;
}

// 线性探测：冲突时索引+1，循环查找
int linearProbe(int index, int i, int tableSize) {
    return (index + i) % tableSize; // i为探测次数
}

#include <iostream>
#include <vector>
#include <list>
#include <string>
using namespace std;
template <typename K, typename V>
class HashTable {
private:
    // 键值对结构
    struct Entry {
        K key;
        V value;
        Entry(K k, V v) : key(k), value(v) {}
    };
    vector<list<Entry>> table; // 哈希表数组（每个元素是链表）
    int size;                  // 当前元素数量
    int capacity;              // 表容量
    const double loadFactorThreshold = 0.7; // 负载因子阈值（触发扩容）
    // 哈希函数（整数键）
    int hash(const K& key) const {
        // 对整数键直接取模
        return key % capacity;
    }
    // 哈希函数（字符串键）- 模板特化
    int hash(const string& key) const {
        int hash = 0;
        for (char c : key) {
            hash = (hash * 31 + c) % capacity;
        }
        return hash;
    }
    // 扩容操作
    void resize() {
        int oldCapacity = capacity;
        capacity *= 2; // 容量翻倍（通常取质数）
        vector<list<Entry>> newTable(capacity);
        // 重新哈希所有元素到新表
        for (int i = 0; i < oldCapacity; i++) {
            for (const Entry& entry : table[i]) {
                int index = hash(entry.key);
                newTable[index].push_back(entry);
            }
        }
        table.swap(newTable); // 替换为新表
    }
public:
    // 构造函数：初始容量默认31（质数）
    HashTable(int initialCapacity = 31) : capacity(initialCapacity), size(0) {
        table.resize(capacity);
    }
    // 插入键值对（若键已存在则更新值）
    void insert(const K& key, const V& value) {
        // 检查负载因子，超过阈值则扩容
        if ((double)size / capacity >= loadFactorThreshold) {
            resize();
        }
        int index = hash(key);
        // 检查是否已存在该键，存在则更新值
        for (Entry& entry : table[index]) {
            if (entry.key == key) {
                entry.value = value;
                return;
            }
        }
        // 不存在则插入新键值对
        table[index].emplace_back(key, value);
        size++;
    }
    // 删除键值对（成功返回true）
    bool remove(const K& key) {
        int index = hash(key);
        for (auto it = table[index].begin(); it != table[index].end(); ++it) {
            if (it->key == key) {
                table[index].erase(it);
                size--;
                return true;
            }
        }
        return false; // 键不存在
    }
    // 查找键对应的值（找到返回true，值通过引用传出）
    bool find(const K& key, V& value) const {
        int index = hash(key);
        for (const Entry& entry : table[index]) {
            if (entry.key == key) {
                value = entry.value;
                return true;
            }
        }
        return false; // 键不存在
    }
    // 获取当前元素数量
    int getSize() const {
        return size;
    }
    // 打印哈希表结构（调试用）
    void print() const {
        for (int i = 0; i < capacity; i++) {
            cout << "Bucket " << i << ": ";
            for (const Entry& entry : table[i]) {
                cout << "(" << entry.key << ":" << entry.value << ") ";
            }
            cout << endl;
        }
    }
};
// 测试代码
int main() {
    // 测试整数键哈希表
    HashTable<int, string> intHash;
    intHash.insert(1, "Apple");
    intHash.insert(2, "Banana");
    intHash.insert(31, "Cherry"); // 31 % 31 = 0，与1%31=1不冲突
    intHash.insert(32, "Date");   // 32 % 31 = 1，与1冲突（拉链处理）
    cout << "整数键哈希表：" << endl;
    intHash.print();
    // 输出：
    // Bucket 0: (31:Cherry) 
    // Bucket 1: (1:Apple) (32:Date) 
    // ...（其他桶为空）
    string val;
    if (intHash.find(32, val)) {
        cout << "找到32: " << val << endl; // 输出：找到32: Date
    }
    intHash.remove(2);
    cout << "删除键2后大小：" << intHash.getSize() << endl; // 输出：3
    // 测试字符串键哈希表
    HashTable<string, int> strHash;
    strHash.insert("Alice", 25);
    strHash.insert("Bob", 30);
    strHash.insert("Charlie", 35);
    cout << "\n字符串键哈希表：" << endl;
    strHash.print();
    return 0;
}

#include <unordered_map>
#include <unordered_set>
#include <iostream>
int main() {
    // unordered_map：键值对存储
    unordered_map<string, int> umap;
    umap["Apple"] = 5;
    umap["Banana"] = 3;
    // 查找
    if (umap.find("Apple") != umap.end()) {
        cout << "Apple: " << umap["Apple"] << endl;
    }
    // unordered_set：唯一元素存储
    unordered_set<int> uset = {1, 2, 3, 2}; // 自动去重
    for (int x : uset) {
        cout << x << " "; // 输出顺序不确定（无序）
    }
    return 0;
}