哈希表原理与双散列实战指南

🌟 Hash 表入门详解：原理 + 开放定址 + 双散列（含 C++ 示例）

哈希表（Hash Table）是一种支持快速插入、删除、查找的高效数据结构，几乎所有编程语言都内置了它的变体（如 C++ 的 unordered_map、Java 的 HashMap）。
本文将通过直观类比 + C++ 示例代码，带你从 0 理解哈希表，特别是 开放定址法与双散列技术。

🧠 一、哈希表的基本思想：映射存储

📦 类比：图书馆中找书

假设你在图书馆找书：

• 正常做法：挨本翻，效率极低；
• 聪明做法：根据书的编号 → 找到固定书架位置。

哈希表也是这样：

把“键值”通过某种规则变成数组下标 —— 哈希函数（Hash Function），然后把值存在这个位置上。

📐 二、哈希函数：让钥匙变成下标

最常用的哈希函数之一是：

h(k) = k % m

• k: 关键字（如学号、身份证号等）
• m: 哈希表大小（通常为质数）
• %: 取余操作，相当于“将所有键值均匀撒到 0~m-1 中”。

示例：

k = 1234, m = 10
h(k) = 1234 % 10 = 4

👉 把编号 1234 的学生记录存到数组下标为 4 的位置。

💥 三、冲突了怎么办？（关键）

🎯 什么是冲突？

不同的 k，可能通过哈希函数算出的下标一样，称为哈希冲突（collision）。

比如：

h(1234) = 4
h(5674) = 4   // 冲突了！

🔁 四、解决冲突：开放定址法（Open Addressing）

✨ 思路：

如果目标位置被占，就往后找空位。

📊 常见策略：

🚀 五、重点：双散列法（Double Hashing）

双散列是一种冲突更少、分布更好的方法，避免“堆积”效应。

📌 双散列公式：

Hi = (hash1(k) + i × hash2(k)) % m

• hash1(k)：主哈希函数，一般是 k % m
• hash2(k)：副哈希函数，常见是 c - (k % c)，其中 c 是小于 m 的质数

这样可以跳跃式探测空位，不容易发生“线性堆积”。

✅ 六、完整 C++ 示例：双散列插入与查找

#include <iostream>
#include <vector>
using namespace std;

const int TABLE_SIZE = 11; // 哈希表大小
const int C = 7;           // 小于表长的质数，用于双散列

class HashTable {
private:
    vector<int> table;
    vector<bool> occupied;

    int hash1(int key) {
        return key % TABLE_SIZE;
    }

    int hash2(int key) {
        return C - (key % C);
    }

public:
    HashTable() : table(TABLE_SIZE, -1), occupied(TABLE_SIZE, false) {}

    // 插入元素
    void insert(int key) {
        int h1 = hash1(key);
        int h2 = hash2(key);

        for (int i = 0; i < TABLE_SIZE; i++) {
            int index = (h1 + i * h2) % TABLE_SIZE;
            if (!occupied[index]) {
                table[index] = key;
                occupied[index] = true;
                cout << "插入 " << key << " 到位置 " << index << endl;
                return;
            }
        }
        cout << "插入失败，表已满\n";
    }

    // 查找元素
    int search(int key) {
        int h1 = hash1(key);
        int h2 = hash2(key);

        for (int i = 0; i < TABLE_SIZE; i++) {
            int index = (h1 + i * h2) % TABLE_SIZE;
            if (!occupied[index]) return -1;
            if (table[index] == key) return index;
        }
        return -1;
    }

    // 打印哈希表
    void print() {
        for (int i = 0; i < TABLE_SIZE; i++) {
            cout << i << ": " << (occupied[i] ? to_string(table[i]) : "空") << endl;
        }
    }
};

int main() {
    HashTable ht;

    // 插入一些元素
    ht.insert(10);
    ht.insert(21);
    ht.insert(32);
    ht.insert(43); // 冲突，尝试双散列探测

    ht.print();

    // 查找测试
    int key = 21;
    int idx = ht.search(key);
    if (idx != -1)
        cout << "找到 " << key << " 在位置 " << idx << endl;
    else
        cout << "未找到 " << key << endl;

    return 0;
}

📊 七、性能分析简述

• 装填因子 α = 已存元素个数 / 表长
• α 越大，冲突越多，性能下降。
• 双散列在开放定址中是性能最优的探测方式之一。
• 在 α < 0.7 时，平均查找长度 ≈ 1~2 次探测。

🎁 八、小结 & 建议