[数据结构与算法]AcWing 840. 模拟散列表

题目来源：AcWing 840. 模拟散列表

一、题目描述

维护一个集合，支持如下几种操作：

1. I x，插入一个数 $x$；
2. Q x，询问数 $x$ 是否在集合中出现过；
   现在要进行 $N$ 次操作，对于每个询问操作输出对应的结果。

输入格式
第一行包含整数 $N$，表示操作数量。

接下来 $N$ 行，每行包含一个操作指令，操作指令为 I x，Q x 中的一种。

输出格式
对于每个询问指令 Q x，输出一个询问结果，如果 $x$ 在集合中出现过，则输出 Yes，否则输出 No。

每个结果占一行。

数据范围
$1\le N\le 10^5$
$?10^9\le x\le 10^9$

输入样例：

5
I 1
I 2
I 3
Q 2
Q 5

输出样例：

Yes
No

二、哈希表

哈希表的存储结构分为：链地址法、开放寻址法（常用）

1. 拉链法

拉链法本质就是邻接表，将重复的元素挂在一条链上。
槽的大小：这里的槽就是指哈希表的单元格，指的就是 $N$，一般而言 $N$ 取 $10^5$ 或 $10^6$ 后面的质数，如 $1e^5+3$ 或者 $1e^6+3$ 这种值。
哈希函数：$hash(x)=(x\%N+N)$
插入操作：利用哈希函数得到哈希值 $k$，然后确定的这个槽就是 $h[k]$

void insert(int x)
{
	int k = (x % N + N) % N; // 哈希函数
	e[idx] = x, ne[idx] = h[k], h[k] = idx++; // 头插法
}

查询操作：与插入操作类似，如果一个 $hash$ 值对应的槽有多个元素挂在上面，则顺序遍历即可。

bool query(int x)
{
	int k = (x % N + N) % N;
	for (int i = h[k]; ~i; i = ne[i])
		if (e[i] == x) return true;
	return false;
}

运行效果对比：使用该方法耗时 $56ms$，使用STL库自带的unordered_set容器耗时 $186ms$。

2. 开放寻址法（常用）

开放寻址法只开了一个数组，但是大小一要开到题目的数据范围的 $2$~$3$ 倍的质数。例如，如果题目中要输入 $1e^5$ 个数，那么这个数组的长度至少开到 $2e^5$~$3e^5+c$ ，这是一个经验值，这样冲突的概率比较低。该方法常用的原因是，可以使用更少的数组个数。

槽的大小：题目的数据范围的$2$~$3$ 倍，同样也是一个质数。
哈希函数：$hash(x)=(x\%N+N)$
冲突处理：如果当前 $h[k]$ 已经被占用，则向上厕所一样一个一个坑位顺序往后找，直到找到第一个空的坑位为止。
find函数：开放寻址法的核心操作是 find 函数，也称为蹲坑法，$find(x)$ 当在哈希表中找打 $x$ 以后，则返回 $x$ 所在的位置；如果 $x$ 在哈希表中不存在的话，则返回它应该存储的位置。

// null 这里要设置一个用不到的标志数，当做标志位
const int N = 200003, null = 0x3f3f3f3f3;
int h[N]; // 要先memset(h, 0x3f, sizeof h);

int find(int x)
{
	int k = (x % N + N) % N;
	while (h[k] != null && h[k] != x) // 要么找到x，要么找到空的坑位
	{
		k++;
		if (k === N) k = 0; // 类似于循环队列
	}
	return k;
}

插入操作：

int k = find(x);
h[k] = x;

查找操作：

int k = find(x);
if (h[k] != null) puts("Yes");
else puts("No");

删除操作：类似于冲突处理，找到以后打一个标记。
运行效果对比：使用该方法耗时 $62ms$，使用STL库自带的unordered_set容器耗时 $186ms$。

三、代码

1. 链地址法

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

// mod的这个数，一般要开质数
const int N = 100003;

int h[N], e[N], ne[N], idx;

// 头插法
void insert(int x)
{
    int k = (x % N + N) % N; // k是hash值
    e[idx] = x, ne[idx] = h[k], h[k] = idx++; // 邻接表的头插法
}

bool find(int x)
{
    int k = (x % N + N) % N;
    for (int i = h[k]; ~i; i = ne[i])
        if (e[i] == x) return true;
    return false;
}

int main()
{
    int n;
    scanf("%d", &n);
    
    // 清空哈希表(邻接表)
    memset(h, -1, sizeof h);
    
    while (n--)
    {
        char op[2];
        int x;
        
        scanf("%s%d", op, &x);
        
        if (*op == 'I') insert(x);
        else
        {
            if (find(x)) puts("Yes");
            else puts("No");
        }
    }
    
    return 0;
}

2. 开放寻址法

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

// 注意：N要开2~3倍数据范围的奇数, null是表示哈希槽尚未占用的标志
const int N = 2e5 + 3, null = 0x3f3f3f3f;
int h[N];
int n;

// 开放寻址法的核心函数
int find(int x)
{
    int k = (x % N + N) % N;
    while (h[k] != null && h[k] != x) 
    {
        k++;
        if (k == N) k = 0;
    }
    return k;
}

int main()
{
    scanf("%d", &n);
    // 要像使用邻接表那样初始化都为null
    memset(h, 0x3f, sizeof h);
    char op[2];
    int x;
    while (n--)
    {
        scanf("%s%d", op, &x);
        
        int k = find(x);
        if (*op == 'I') h[k] = x;
        else
        {
            if (h[k] != null) puts("Yes");
            else puts("No");
        }
    }
    
    return 0;
}