哈希表的介绍

基本概念
哈希表可以存储各种类型的数据，当我们从哈希表中查找所需要的数据时，理想情况是不经过任何比较，一次存取便能得到所查记录，那就必须在记录的存储位置和它的关键字之间建立一个确定的对应关系 f，使每个关键字和结构中一个唯一的存储位置相对应。(关键字就是所要存储的数据，存储位置相当于数组的索引)。

哈希表常用的两种存储方法：1.开放寻址法 2.拉链法

拉链法：首先对关键码集合用散列函数计算散列地址，具有相同地址的关键码归于同一子集合，每一个子集合称为一个桶，各个桶中的元素通过一个单链表链接起来，各链表的头结点存储在哈希表中。
设元素的关键码为37, 25, 14, 36, 49, 68, 57, 11, 散列表为HT[12]，表的大小为12，散列函数为Hash(x) = x % 11
Hash(37)=4
Hash(25)=3
Hash(14)=3
Hash(36)=3
Hash(49)=5
Hash(68)=2
Hash(57)=2
Hash(11)=0
使用哈希函数计算出每个元素所在的桶号，同一个桶的链表中存放哈希冲突的元素。

注意：一般取模的那个数为质数，这样哈希冲突的可能性比较小。

例题：拉链法
模板

(1) 拉链法
    //h中存储idx的值
    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;
    }

题解：

#include <iostream>
#include <string.h>
const int N = 100003;

int h[N], e[N], ne[N], idx = 0;
using namespace std;
void insert(int x)
{
    int k = (x % N + N) % N; //求取卡槽值，由于x可能是负数，所以+N
    e[idx] = x;    //这里每次都是插入到链表头部
    ne[idx] = h[k];
    h[k] = idx ++;
}

bool query(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 m;
    scanf("%d", &m);
    memset(h, -1, sizeof h);
    while(m --)
    {
        char op[2];
        int n;
        scanf("%s%d", op, &n);
        if (op[0] == 'I')
        {
            insert(n);
        }
        if (op[0] == 'Q')
        {
            if(query(n))
            {
                puts("Yes");
            }
            else {
                puts("No");
            }
        }
    }
}

(2)开放寻址法
开放寻址法：又称开放定址法，当哈希冲突发生时，从发生冲突的那个单元起，按照一定的次序，从哈希表中寻找一个空闲的单元，然后把发生冲突的元素存入到该单元。这个空闲单元又称为开放单元或者空白单元。开放寻址法需要的表长度要大于等于所需要存放的元素数量，非常适用于装载因子较小(小于0.5)的散列表。

模板如下：

    int h[N]; //h数组中存储目标值

    // 如果x在哈希表中，返回x的下标；如果x不在哈希表中，返回x应该插入的位置
    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;
    }

例题：

#include <string>
#include <iostream>
#include <cstring>
//#include <limits.h>
using namespace std;

const int N = 200003; //开放寻址法一般开的数组的大小为2倍
const int INT_MAX = 0x3f3f3f3f;//这个数不在x的范围内，给数组默认值
int h[N];

//find返回值：若找到x值则返回其下标，若找不到，则返回能容纳其位置的下标
int find(int x)
{
    int k = (x % N + N) % N;
    while (h[k] != INT_MAX && h[k] != x)
    {
        k++;
        if (k == N) {  //k如果超过数组的边界，则返回从0开始遍历
            k = 0;
        }
    }
    return k;
}

int main()
{
    int n;
    scanf("%d", &n);
    memset(h, 0x3f, sizeof(h));//memset是按照字节来复制的，一般memsets的赋值去-1,0，因为按字节赋值完后依然是-1,0
    char op[2];
    int num;
    while(n--)
    {
        scanf("%s%d",op,&num);
        if (op[0] == 'I')
        {
            h[find(num)] = num;
        } else {
            if(h[find(num)] != INT_MAX) {
                cout << "Yes" << endl;
            } else {
                cout << "No" << endl;
            }
        }
    }
    return 0;
}

另外介绍一种重要的哈希方式：字符串哈希方式（典型的是字符串前缀哈希法）
字符串前缀哈希法将字符串前缀转为一个P进制的数存储，每个前缀都对应唯一一种字符串
h[N] 存放字符串的前缀值
p[N]存放各个位数的相应权值

注：不能把字母 映射成0 ( 从1开始 )，比如上面将A映射成1，B映射成2，C映射成3，D映射成4
步骤：
1.把字符串看作是P进制数 （按经验P一般取131或者13331,Q取成2^64，哈希冲突的概率极低）
2.预处理字符串所有的前缀hash值 h [ i ] = h [ i - 1 ] * P + str [ i ] ; str[i]这儿相当于str[i]*P^0
3.计算子串hash值 h [ r ] - h [ l - 1 ] * p [ r - l + 1 ] ;

模板：

核心思想：将字符串看成P进制数，P的经验值是131或13331，取这两个值的冲突概率低
小技巧：取模的数用2^64，这样直接用unsigned long long存储，溢出的结果就是取模的结果

typedef unsigned long long ULL;
ULL h[N], p[N]; // h[k]存储字符串前k个字母的哈希值, p[k]存储 P^k mod 2^64

// 初始化
p[0] = 1;
for (int i = 1; i <= n; i ++ )
{
    h[i] = h[i - 1] * P + str[i];
    p[i] = p[i - 1] * P;
}

// 计算子串 str[l ~ r] 的哈希值
ULL get(int l, int r)
{
    return h[r] - h[l - 1] * p[r - l + 1];
}

例题：

片描述

#include <iostream>在这里插入图片描述

using namespace std;

typedef unsigned long long ULL;     //使用ULL相当于自动取模 Q = 2^64-1

const int N = 1e5 + 10, P = 131;    //P为进制数    
//经验值: P取131或13331, Q取2^64(99.99%的情况不会发生冲突)

ULL h[N], p[N];     // h[i]存储前i个字符的hash值, p[]存储次方

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

int main() {
    int n, m;
    cin >> n >> m;
    string str;
    cin >> str;

    p[0] = 1;
    for(int i = 0; i < n; i++) {
        p[i+1] = p[i] * P;
        h[i+1] = h[i] * P + str[i];
    }

    while(m--) {
        int l1, r1, l2, r2;
        cin >> l1 >> r1 >> l2 >> r2;
        if(query(l1,r1) == query(l2,r2)) puts("Yes");
        else puts("No");
    }

    return 0;
}