神机百炼1.23-拉链法哈希

starnight531

已于 2022-05-16 17:07:41 修改

阅读量627

点赞数 15

分类专栏： acwing 文章标签：哈希算法数据结构算法 c++ 散列表

于 2022-05-14 15:50:59 首次发布

本文链接：https://blog.csdn.net/buptsd/article/details/124740778

版权

acwing 专栏收录该内容

58 篇文章 2 订阅

订阅专栏

拉链法哈希导图

拉链法哈希表

本篇感想：

食用指南：

对该算法程序编写以及踩坑点很熟悉的同学可以直接跳转到代码模板查看完整代码
只有基础算法的题目会有关于该算法的原理，实现步骤，代码注意点，代码模板，代码误区的讲解
非基础算法的题目侧重题目分析，代码实现，以及必要的代码理解误区

题目描述：

维护一个集合，支持如下几种操作：
I x，插入一个数 x；
Q x，询问数 x 是否在集合中出现过；
现在要进行 N 次操作，对于每个询问操作输出对应的结果。

输入格式
第一行包含整数 N，表示操作数量。
接下来 N 行，每行包含一个操作指令，操作指令为 I x，Q x 中的一种。

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

数据范围
1≤N≤105
−109≤x≤109
输入样例：
5
I 1
I 2
I 3
Q 2
Q 5
输出样例：
Yes
No
题目来源：

题目分析：

数x最大一亿，数组存不下

输入最多十万，数组存的下
将无限大的数存储在有限大的数组/向量中
马上想到的是离散化，没毛病

精确来讲，单纯用于插入和查询的数据结构叫哈希表

离散化是特殊的哈希方式：需要去重+排序
本讲将介绍哈希表的两大实现方式：

开放寻址法 & 拉链法中的拉链法

开放寻址法哈希看这里：传送门

算法原理：

1. 哈希冲突：

将大数映射到小范围内的最简方式就是 % 小数N
举例：
将 2987654321，3987654321，4987654321，5987654321…映射到0 - 5的范围内：

2987654321 % 6 = 5;
3987654321 % 6 = 3;
4987654321 % 6 = 1;
5987654321 % 6 = 5;

可以用arr[1]存储4987654321
arr[3]存储3987654321
但是使用arr[5]时候产生了歧义

则称2987654321和5987654321发生了哈希冲突
含义：
模的小数N就是哈希表的表长N

若两个数%表长N之后的余数相同，则称这两个数发生了哈希冲突

由处理哈希冲突的方式不同，将哈希表的构建方式分为拉链法和开放寻址法

哈希映射：

//将大数映射到小数范围内的最简方法是 大数 % 小数，没毛病
//但是负数 % 小数 可能还是负数，但是是-小数内的负数

//保证映射结果>=0
int x = -2987654321;
int N = 6;
int idx = (x%N + N) % N;

看到(x%N + N) % N的方法熟悉吗？
其实我们在高精度减法详细讲过哦：传送门

2. 哈希表表长：

为了避免哈希冲突，所以我们选取哈希表表长也需要注意

开一个10⁵长(最好为质数)的数组，作为哈希表最好

代码中确定哈希表表长用到了质数打表

3. 拉链法：

上述arr[5]节点对应着两个数：2987654321和5987654321

不妨在5这个节点拉出一条链表，链表有两个节点：2987654321 和 5987654321

当查找这两个数时，我们先取模，找到arr[5]，再遍历arr[5]拉出的单链表，就能找到这两个数

反之，有未存储的数，虽然同样%6 == 5;
但是从arr[5]遍历单链表的时候找不到这个数

4. 数组模拟单链表：

不熟悉静态链表的同学看这里：
静态单链表
 静态双链表
我们只需要用静态单链表即可
初始化：
在单链表中，若链表为空，head = -1;
在哈希表中的第i个拉链的头节点是Hash[i]
所以哈希表中未插入元素时，所有Hash[i]亦是-1
idx变量：
在为哈希表中的一格元素拉单链表的时候，肯定采用头插法
虽然不同格元素可以拉出很多条单链表，
但是所有节点都是通过节点序号idx变量创建出来的，
现在物理地址相邻的两个节点，可以从属于不同的链表

1. 哈希表初始化代码：

//1,找一个十万后的质数作为表长，减少哈希冲突：
int N = 0;
for(int i=100000; i++){
	int flag = 1;
    for(int j=2; j*j<i; j++){
		if(i%j == 0){
			flag = 0;
            break;
        }
    }
    if(flag){
		N = i;
    }
}
//2,节点初始化：
int Hash[N];
int arr[N], next[N],idx = 0;
memset(Hash, -1, sizeof(Hash));

哈希表中插入元素：
哈希表Hash[i]本身也存储的是节点idx，是Hash[i]拉出的链表的头节点
由于采用头插法，每次向Hash[i]所引导的链表插入元素时，新插入的节点成为了新的头节点，原头节点成为新头节点的next[]
和静态链表同理，由于开始Hash[i]=-1，所以所有链表的尾巴都指向-1

现在向Hash[k]插入节点，经典问题又来：大象装进冰箱有几步？
1. 创捷新节点(创新)：
arr[idx] = val;
2. 老链表连接到新节点上(连旧)：
next[idx] = Hash[k];
1. 新链表放回Hash[k]中 (放回)：
  Hash[k] = idx++;

2. 插入节点代码：

void insert(int x){
	//大数x对应的小数k映射，没别哒，就是％，保证结果非负
	int k = (x%N + N)% N;
	arr[idx] = x;
	next[idx] = Hash[k];
	Hash[k] = idx++;
}

3. 查询哈希表代码：

有了上面的拉链哈希表原理介绍，那查找很简单了
一句话，遍历数x映射到的Hash[k]所连接的静态链表

int search(int x){
	//先找到是哪个链表
	int k = (x%N + N) % N;
	int t = Hash[k];
	//再遍历这个链表
	while(t != -1){
		if (arr[k] == x) return k;
		k = next[k];
	}
	return -1;
}