【算法竞赛模板】哈希表(开放寻址法、拉链法、字符串哈希方式)

Ac君

已于 2022-04-14 09:03:55 修改

阅读量1.4k

点赞数

分类专栏：算法学习文章标签：哈希表哈希算法 hash 蓝桥杯算法模板

于 2022-04-13 20:21:49 首次发布

本文链接：https://blog.csdn.net/u012011079/article/details/124144936

版权

算法学习专栏收录该内容

19 篇文章 11 订阅

订阅专栏

哈希表

存储结构
- 一、拉链法
- 二、开放寻址法
代码模板
字符串哈希方式

本蒻苟发文，有任何不足欢迎大佬们斧正~（＾∀＾●）ﾉｼ
在这里插入图片描述

存储结构

一、拉链法

拉链法的存储形式如下，同个key里挂钩了不同的元素
在这里插入图片描述
核心形式： hash(key) = key % N
注意： 我们对哈希表一般只做查找和新增操作，如果要做删除操作最好是额外开一个bool类型的数组来打标记
实现方式： 我们通常开一个长度为 N 的数组，这个 N 最好是一个质数，如数据范围为 1e5 ，那么 N 应该取为 1e5+3(质数)，而且这个质数要离 2ⁿ(n为整数)尽可能的远，这样当 %N 时可使当前这个哈希表起冲突的数量比较少，N取为质数可通过试除法先求出质数。如果key有重复，就和上图一样挂在把 key 对应的元素挂在 key 下面
优点： ①解决了线性探测所导致的太多的哈希冲突 ②删除节点相比开放寻址法更容易实现 ③搜索的时间下降 ④适用于造表前无法确定表长的情况
缺点： 如果相同元素过多，元素在同一个桶内部链接过长，反而会导致时间复杂度上升。解决思路使，桶中的元素不再指向链表，而指向一个红黑树

二、开放寻址法

在这里插入图片描述
核心形式： hash(key) = key % N
注意： 我们对哈希表一般只做查找和新增操作，如果要做删除操作最好是额外开一个bool类型的数组来打标记，和查找的过程类似
实现形式： 通常我们会开一个长度为 N 的2倍或者3倍数组，这个 N 也需要是质数， 2ⁿ(n为整数)尽可能的远，这样才可以减少冲突。我们是从前往后去找空的坑位，找到空的坑位就把元素放入，找到了最后面还没发现空位的话就从头开始找 ~~(简单来说就像你想蹲坑找厕所一样，当前坑位被占了，你就得找下一个空闲的坑位)~~。
优点： ①当节点规模较少，或者装载因子较少的时候，使用开放寻址较为节省空间
优点： 容易产生堆积问题；不适于大规模的数据存储，而且散列函数的设计对冲突会有很大的影响

代码模板

👉对应习题：Acwing - Saber → 训练模式 → 数据结构 → 哈希表 → 模拟散列表
在这里插入图片描述
👇拉链法 - 模板

/** 拉链法 */
#include<bits/stdc++.h>
using namespace std;

const int N = 100003;

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

void insert(int x){
	int k = (x % N + N) % N;	// + N是为了矫正负数取模为负值的情况
	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;
}

👇开放寻址法 - 模板

/** 开放寻址法 */
#include <bits/stdc++.h>
using namespace std;

const int N = 2e5+3, null = 0x3f3f3f3f;

int h[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(){
	/**		计算质数
	for(int i = 200000; ;i++){
		bool flag = true;
		for(int j = 2; j*j <= i; j++)
			if(i % j == 0){
				flag = false;
				break;
			}
		if(flag){
			cout << i << endl;
			break;
		}
	} */
	
    int n;
    scanf("%d", &n);
    memset(h, null, sizeof h);	//不能将将h设为-1，因为数据范围N有负数的
    
    while(n--){
        char op[2];
        int x;
        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;
}

字符串哈希方式

根据y总说，这个方法很牛批，很多KMP算法望而却步的这方法都能做，而且用途还挺广的，可用于快速比较两个字符串。
实质： 字符串哈希实质上就是把每个不同的字符串转成不同的整数
推导： y总经验之谈，P一般取131或者13331，Q取 2⁶⁴，所以Q直接用 unsigned long long 存储。P为进制，Q为要 % 的数
时间复杂度： O(1)
在这里插入图片描述
推导如下图

h[R] = P^R-1+ P^R-2+ … + P⁰，h[R] 在 R-1 位
h[L-1] = P^L-2+ P^L-3 + P⁰，h[L-1] 在 L-2 位
要使得 h[L-1] 与 h[R] 从高位对齐，则 h[L-1] 需乘上一个 P^R-L+1
结论： 某一区间的哈希值为 hash[R] - hash[L - 1] × P^R-L+1

👉对应习题：Acwing - Saber → 训练模式 → 数据结构 → 哈希表 → 字符串哈希
在这里插入图片描述

#include <bits/stdc++.h>
using namespace std;
typedef unsigned long long ULL;

const int N = 100003, P = 131;

int n, m;
char str[N];
ULL h[N], p[N];		//p是乘了多少次方

ULL get(int l, int r){
	return h[r] - h[l - 1] * p[r - l + 1];
}

int main(){
	scanf("%d%d%s", &n, &m, str + 1);
	p[0] = 1;							//p的0次方为1
	for(int i = 1; i <= n; i++){
		p[i] = p[i - 1] * P;			//计算p为几次幂
		h[i] = h[i - 1] * P + str[i];	//到当前字符串哈希值，str[i]这相当于str[i] * P^0
	}
	
	while(m--){
		int l1, r1, l2, r2;
		scanf("%d%d%d%d", &l1, &r1, &l2, &r2);
		
		if(get(l1, r1) == get(l2, r2)) puts("Yes");
		else puts("No");
	}
	return 0;
}