算法基础16-数组模拟散列表、hash表

散列表

开放寻址法

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

//开放寻址法一般开 数据范围的 2~3倍, 这样大概率就没有冲突了
const int N = 2e5 + 3;        //大于数据范围的第一个质数


const int null = 0x3f3f3f3f; //可以去百度0x3f3f3f这个数在c++竞赛中作为无穷大的好处

// 开放寻址法

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;//t代表着x经过我们自己定义的hash函数运算后应该存在数组中的哪个位置
}

int main()
{
    memset(h, 0x3f,sizeof h);
    int n;
    cin >> n;
    char op[2];
    while (n -- )
    {
        int x;
        scanf("%s", op);
        scanf("%d", &x);
        if (*op == 'I') h[find(x)] = x;
        else if (h[find(x)] != null)
        {
            cout << "Yes" << endl;
        }
        else cout << "No" << endl;
    }
    return 0;
}

拉链法

#include <iostream>
#include <cstring>

using namespace std;

const int N = 1e5 + 3;


//后面三个是链表的数据结构，第一个hash表用来记录每个链表在hash表的位置 h[k] = 每个链表头节点的编号--idx
int h[N], e[N], ne[N], idx;

void insert(int x)
{
    int k = (x % N + N) % N;//防止负数
    //链表的模版 头插法 重点是理解h[k]的意义 
    e[idx] = x;
    ne[idx] = h[k];
    h[k] = idx ++ ;
}

bool find(int x)
{
    int k = (x % N + N) % N;//计算x对应的在h数组中的位置，x存在h数组里哪个下标下的链表里去了
    for (int i = h[k]; i != -1; i = ne[i])
    {
        if (e[i] == x) return true;
    }
    return false;
}

int main()
{
    memset(h, -1,sizeof h);//拉链法用-1当作空指针，开放寻址法是 0x3f3f3f3f，原因是h[]存的是idx 其值不可能有负数
    int n;
    cin >> n;
    char op[2];
    while (n -- )
    {
        int x;
        scanf("%s", op);
        scanf("%d", &x);
        if (*op == 'I') insert(x);
        else if (find(x))
        {
            cout << "Yes" << endl;
        }
        else cout << "No" << endl;
    }
    return 0;
}

hash表

//acwing 841. 字符串哈希
#include <iostream>

using namespace std;

typedef unsigned long long ULL;

const int N = 1e5 + 10;

const int P = 131;//p进制取这个数冲突最小或者13331也可以

// h[i]前i个字符的hash值
// 字符串变成一个p进制数字，体现了字符+顺序，需要确保不同的字符串对应不同的数值
// P = 131 或  13331 Q=2^64，在99%的情况下不会出现冲突
// 使用场景： 两个字符串的子串是否相同

ULL h[N], p[N];//h数组记录不同长度的字符串经过映射后的hash值，p数组记录不同次方P进制的值

int n, m;

ULL query(int l, int r)//计算此区间的hash值
{
    return h[r] - h[l - 1] * p[r - l + 1];
}

int main()
{
    p[0] = 1;
    //h[0] = 0;全局数组默认为0，这个可以不写
    cin >> n >> m;
    char s[N];
    scanf("%s", s + 1);
    for (int i = 1; i <= n; i ++ )//初始化h，p数组
    {
        h[i] = h[i - 1] * P + s[i];
        p[i] = p[i - 1] * P;
    }
    while (m -- )
    {
        int l1, r1, l2, r2;
        scanf("%d%d%d%d", &l1, &r1, &l2, &r2);
        if (query(l1, r1) == query(l2, r2)) cout << "Yes" << endl;
        else cout << "No" << endl;
    }
    return 0;
}