算法基础课—数据结构（八） 哈希表

哈希表的作用——在什么时候会用到哈希表

把一个比较庞大的值域映射到一个比较小的值域。

哈希表和离散化的区别在于，离散化可能是为了解决空间的问题，哈希表是为了解决时间的问题，更方便查找

哈希表中需要解决的问题

1. 映射怎么选？即哈希函数怎么选 可以是取模 如 x mod 5 模的数尽量取质数，这样冲突的概率会尽可能的小

2. 冲突怎么解决

哈希表的两种方法

1. 拉链法

2. 开放寻址法

拉链法

思想

开设一个一维数组（槽）
解决冲突的方法：在这个槽上拉一个链，来存储这个槽上的数，也就是说，如果这个槽有多个数是冲突的，则用链把他们存储起来。

哈希表的操作

添加——找到槽，添加到链上
查找——找到槽，查找链

代码写法

e[N],ne[N],idx ——链表操作，可存储多个链表——存储多个拉链

h[k] 1-10的5次方的数组 ,k对应的是第几个槽，h[k]保存的是这个槽拉的链的头结点，其指向的下一个节点的idx下标。

模板代码

#include <cstring>
#include <iostream>

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;
    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 != -1; 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;
}

作者：yxc
链接：https://www.acwing.com/activity/content/code/content/45308/
来源：AcWing
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

自己的代码

//拉链法
#include <iostream>
#include <cstring>//如果使用memset要用头文件
using namespace std;
const int N = 100003;//找到大于100000的最小质数
int h[N], e[N],ne[N],idx = 0;
void insert(int x){
    int k = (x % N + N) % N;
    int hk = h[k];
    idx++;
    e[idx] = x;
    ne[idx] = hk;
    h[k] = idx;
}
bool find(int x){
    int k = (x % N + N) % N;
    int hk = h[k];
    int t = hk;
    while(t != -1){
        if(e[t] == x)
            return true;
        t = ne[t];
    }
    return false;
}
int main(){
    int n, i, x;
    cin>>n;
    char op[2];
    memset(h, -1, sizeof(h));
    for(i = 0; i < n; i ++){
        scanf("%s%d",op,&x);
        if(op[0] == 'I')
            insert(x);
        else if(op[0] == 'Q'){
            if(find(x)) cout<<"Yes"<<endl;
            else cout<<"No"<<endl;
        }

    }
}

开放寻址法

开设一个一维数组，数组的范围一般为题目所给范围的2-3倍

算法思路：

就是从第k个开始找，如果第k个有人，就往下找，直到有空的，就放进去，类似于上厕所

代码思路

1. 先找大于数组范围的最小质数，作为取模的数
2. 然后开设一个一维数组，赋初值，要选定一个null值作为当前为空的标志，要题目给定的数的范围内，这里选的0x3f3f3f3f。
3. find函数，如果有x，则返回当前x位置，没有则返回x应该插入的位置。注意如果k到达N，还没有停止循环，则从0继续搜索。
4. 插入查找操作

模板代码

#include <cstring>
#include <iostream>

using namespace std;

const int N = 200003, null = 0x3f3f3f3f;

int h[N];

int find(int x)
{
    int t = (x % N + N) % N;
    while (h[t] != null && h[t] != x)
    {
        t ++ ;
        if (t == N) t = 0;
    }
    return t;
}

int main()
{
    memset(h, 0x3f, sizeof h);

    int n;
    scanf("%d", &n);

    while (n -- )
    {
        char op[2];
        int x;
        scanf("%s%d", op, &x);
        if (*op == 'I') h[find(x)] = x;
        else
        {
            if (h[find(x)] == null) puts("No");
            else puts("Yes");
        }
    }

    return 0;
}

作者：yxc
链接：https://www.acwing.com/activity/content/code/content/45308/
来源：AcWing
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

自己的代码

//开放地址法
#include <iostream>
#include <cstring>//如果使用memset要用头文件
using namespace std;
const int N = 200003, null = 0x3f3f3f3f;//N 是大于200000的最小质数
int h[N];
int find(int x){//返回如果x存在，返回x所在的位置，如果x不存在，返回x插入的位置
    //由于h[k]有可能等于负数，所以，不能用-1来代替空，应该取一个-10的9次方和10的9次方之外的处，作为空节点的标记
    int k = (x % N + N) % N;
    while(h[k] != x && h[k] != null ){
        k ++;
        if(k == N) k = 0;//如果到了末尾还没有找到，就令k=0开始继续找，也就是说循环找，找到有空的为止
    }
    return k;
}
int main(){
    int n, i, x;
    cin>>n;
    char op[2];
    memset(h, 0x3f, sizeof(h));
    for(i = 0; i < n; i ++){
        scanf("%s%d",op,&x);
        if(op[0] == 'I'){
            h[find(x)] = x;
        }
        else if(op[0] == 'Q'){
            if(h[find(x)] == x) cout<<"Yes"<<endl;
            else cout<<"No"<<endl;
        }

    }
}

字符串哈希方式

字符串哈希——在很多字符串操作中都可以用
字符串前缀哈希法（哈希表的h[i]即为第i为前缀和，所以可以求任意子串的值）

核心

用p进制来表示字符串，则可以用一个数值来表示字符串，方便了字符串的比较

h[N]的构造——这个前缀字符串的hash值

字符串hash值的求法

将字符串用p进制来表示，由于这样表示的数可能比较大，所以再对他取模

映射要注意的：

不能映射成0 会产生冲突

这里不考虑冲突情况

对于P，Q取值，一般这么取

这样构造的好处

可以利用前缀的哈希值，计算出任意子串的哈希值

公式h[r] - h[l - 1] *p[r - l + 1]

公式先左移h[l],再相减

用unsigned long long 存储h ，可以省略取模过程，因为其溢出就直接取模了

自己的代码

#include <iostream>
using namespace std;
const int N = 1e6 + 10;
typedef unsigned long long ULL;//将哈希表定义成这样方便取mod ，Q= 2的64次方
char str[N];
int P = 131;
ULL h[N], p[N];
ULL get(int l, int r)
{
    return h[r] - h[l - 1] * p[r - l + 1];
}

int main(){
    int n, m, i;
    int l1,r1,l2,r2;
    ULL lr1,lr2;
    cin>>n>>m;
    scanf("%s", str + 1);//让字符串从1开始
    //先构造该字符串的哈希表
    p[0] = 1;
    for(i = 1; i <= n; i ++){
        h[i] =  h[i - 1] * P + str[i];
        p[i] = p[i - 1] * P;//关于为什么不用pow，而是直接用p存储，因为pow还需要再次计算，浪费时间复杂度，而在计算哈希的过程中， 就可以直接叭p算了
    }
    for(i = 0; i < m; i ++){
        cin>>l1>>r1>>l2>>r2;
        if (get(l1, r1) == get(l2, r2)) cout<<"Yes"<<endl;
        else cout<<"No"<<endl;
    }
}