数据结构——哈希详解

数据结构------哈希详解

目录

一、哈希的定义

二、六种哈希函数的构造方法

[2.1 除留取余法](#2.1 除留取余法)

[2.2 平方取中法](#2.2 平方取中法)

[2.3 随机数法](#2.3 随机数法)

[2.4 折叠法](#2.4 折叠法)

[2.5 数字分析法](#2.5 数字分析法)

[2.6 直接定值法](#2.6 直接定值法)

三、四种解决哈希冲突的方法

[3.1 开放地址法](#3.1 开放地址法)

[3.1.1 线性探测法](#3.1.1 线性探测法)

[3.1.2 二次探测法](#3.1.2 二次探测法)

[3.2 链地址法](#3.2 链地址法)

[3.3 再散列函数法](#3.3 再散列函数法)

[3.4 公共区溢出法](#3.4 公共区溢出法)

四、用代码解决链地址法

---

一、哈希的定义

顺序表/链表有一个共同特征，数据值本身和其存储位置之间是没有关系的，所以我们要查找/搜索一个值，只能一个一个的去比较，时间复杂度是O(n),

我们想把时间复杂度降下来，提供一种技术让我们数据值本身和存储关系之前有映射关系，这时我们查找值是否存在则直接根据这种映射关系计算得出其存储位置，这时只去要去计算得出的存储位置查看即可------这种技术就是散列技术也就是哈希，映射关系就是哈希函数f

f(关键字key)=存储位置

哈希即是一种存储方法也是一种查找方法

哈希冲突定义：俩个或多个关键码Key1!=Key2但是通过哈希函数的计算得出的结果却相等，这种现象就是发生了哈希冲突

二、六种哈希函数的构造方法

2.1 除留取余法

原理：

• 哈希函数 h(k)=k mod m，其中 k 是键值，m 是哈希表的大小。

• 通过取键值 k 除以 m 的余数来确定哈希值。

优点：

• 实现简单，计算速度快。

缺点：

• 如果键值分布不均匀，容易导致冲突。例如，当键值都是偶数时，若 m 是偶数，那么所有哈希值也都是偶数，会浪费一半的哈希表空间。

• 对 m 的选择敏感，通常 m 选择为质数可以减少冲突。

应用场景：

• 适用于键值范围较大且分布较为均匀的场景，如简单的哈希表设计。

2.2 平方取中法

原理：

• 将键值 k 平方，然后从平方后的结果中取出中间几位数字作为哈希值。

• 例如，键值 k=1234，平方后为 1522756，取中间几位（如 2275）作为哈希值。

优点：

• 能够较好地打乱键值的分布，减少冲突。

缺点：

• 如果键值较小，平方后的数字位数不够，可能需要补零，导致哈希值不够随机。

• 计算平方操作相对耗时。

应用场景：

• 适用于对哈希值随机性要求较高的场景，但计算资源允许的情况下。

2.3 随机数法

原理：

• 使用伪随机数生成器（PRNG）根据键值生成随机数作为哈希值。

• 通常需要一个种子值，种子值可以根据键值计算得到。

优点：

• 哈希值的随机性高，冲突概率低。

缺点：

• 随机数生成器的实现复杂，且需要保证每次计算结果一致（即相同的键值产生相同的哈希值）。

• 如果随机数生成器质量不高，可能会导致哈希值分布不均匀。

应用场景：

• 适用于对哈希值随机性要求极高的场景，如密码学中的哈希函数。

2.4 折叠法

原理：

• 将键值分成若干部分，然后将这些部分进行折叠（相加、相减或按位运算）以生成哈希值。

• 例如，键值 k=12345678，可以分成 1234 和 5678，然后相加得到 6912，再取模或者直接取后三位得到最终哈希值。

优点：

• 简单易实现，能够较好地处理较长的键值。

缺点：

• 如果键值的某些部分分布不均匀，可能会影响哈希值的分布。

• 对折叠操作的选择敏感，不同的折叠方式可能导致不同的效果。

应用场景：

• 适用于键值较长且分布不均匀的场景，如字符串哈希。

2.5 数字分析法

原理：

• 分析键值的每一位数字（或字符），根据某种规则选择部分数字组合成哈希值。

• 例如，键值 k=12345678，可以选择第 2、4、6 位数字（2、4、6），然后组合成 246 作为哈希值。

优点：

• 能够根据键值的分布特点进行优化，减少冲突。

缺点：

• 实现复杂，需要对键值的分布有先验知识。

• 如果键值的分布变化较大，可能需要重新调整规则。

应用场景：

• 适用于对键值分布有明确了解的场景，如特定的数据库索引设计。

2.6 直接定值法

原理：

• 取关键字的线性函数值作为散列地址 f(key)=axkey+b

• 通常用于键值范围较小且连续的情况。

优点：

• 实现极其简单，没有冲突。

缺点：

• 如果键值范围较大，会浪费大量空间。

• 不适用于键值范围较大的场景。

应用场景：

• 适用于键值范围较小且连续的场景，如小型数据库索引。

三、四种解决哈希冲突的方法

哈希冲突定义：俩个或多个关键码Key1!=Key2但是通过哈希函数的计算得出的结果却相等，这种现象就是发生了哈希冲突

3.1 开放地址法

3.1.1 线性探测法

原理：当发生哈希冲突时，从冲突位置开始，按照线性顺序依次探测下一个位置，向右探测，直到找到空闲位置为止。即若哈希地址为 h(key) 的位置已被占用，则依次探测 h(key)+1、h(key)+2、h(key)+3...... 直到找到空闲位置。

优点：实现简单，容易理解和编程实现。

缺点：容易出现 "聚集" 现象，即连续的多个空闲位置被占用，形成一个聚集区，导致后续元素查找和插入时需要探测更多的位置，效率降低。

公式：f(key)=(f(key)+d)mod m d=1，2，3，4，5...

3.1.2 二次探测法

使用线性探测法会发生堆积，我们想要探测的时候即向左也向右探测并且每次探测幅度尽可能变化，呈指数变化 eg：1，-1，4，-4，9，-9

增加平方运算是为了不让关键字都聚集在某一个区域

优点：能有效减少聚集现象，提高哈希表的性能。

缺点：不能探测到哈希表中的所有位置，可能会出现无法找到空闲位置的情况，特别是当哈希表大小不是合适的数值时。

3.2 链地址法

其核心思想是将所有哈希地址相同的元素都链接到同一个链表中。在哈希表中，每个位置对应一个链表，当发生哈希冲突（即不同的关键字通过哈希函数计算得到相同的哈希地址）时，将这些冲突的元素依次插入到对应的链表中

优点：

• 处理冲突简单，不需要探测。

• 删除元素容易，只需从链表中移除即可。

缺点：

• 需要额外的空间来存储链表。

• 当一个槽位的链表很长时，搜索效率会降低。

3.3 再散列函数法

再散列函数法使用两个不同的哈希函数。第一个哈希函数 h1(key) 用于计算元素的初始哈希地址。当该地址发生冲突时，使用第二个哈希函数 h2(key) 来确定下一个探测位置的步长，从而在哈希表中寻找下一个可用的位置。

通过这种方式，不断尝试新的位置，直到找到一个空槽来插入元素，或者确定该元素不存在于哈希表中。

3.4 公共区溢出法

不冲突放到基本表中，冲突就放到溢出表中，基本表中都没有数据为空说明溢出表中肯定没有，基本表由哈希函数构成，溢出表由顺序存储构成先来先到，

适用于哈希冲突相对较少的场景

四、用代码解决链地址法

.cpp

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include "hash_List_address.h"
#include <stdlib.h>

//0.哈希函数
int Hash(ELEM_TYPE val)
{
    return val % INITSIZE;
}

//1.初始化
void Init_List_Address(List_address* pla)
{
    for (int i = 0; i < INITSIZE; i++)
    {
        Init_List(&pla->arr[i]);
    }
}

//2.插入值(头插)
bool Insert(List_address* pla, ELEM_TYPE val)
{
    //assert

    int index = Hash(val);

    struct Node* pnewnode = (Node*)malloc(sizeof(Node));
    if (pnewnode == NULL)
    {
        return false;
    }

    pnewnode->data = val;

    pnewnode->next = pla->arr[index].next;
    pla->arr[index].next = pnewnode;

    return true;
}

//3.删除值
bool Del(List_address* pla, ELEM_TYPE val)
{
    struct Node* q = Search(pla, val);
    if (q == NULL)
        return false;

    //此时，代码执行到这里，证明val值节点存在在index下标里面的单链表上

    int index = Hash(val);
    struct Node* p = &pla->arr[index];
    for (; p->next != q; p = p->next);
    
    //此时，代码执行到这里，证明p和q都就位
    p->next = q->next;
    free(q);
    q = NULL;

    return true;
}

//4.查找值
struct Node* Search(List_address* pla, ELEM_TYPE val)
{
    //assert

    int index = Hash(val);
    struct Node* q = pla->arr[index].next;
    for (; q != NULL; q = q->next)
    {
        if (q->data == val)
        {
            break;
        }
    }
    
    return q;
   
}

//5.打印
void Show(List_address* pla)
{
    for (int i = 0; i < INITSIZE; i++)
    {
        printf("第%d行：", i);

        struct Node* p = pla->arr[i].next;
        for (; p != NULL; p=p->next)
        {
            printf("%d->", p->data);
        }
        printf("\n");
    }
}

int main()
{
    List_address head;
    Init_List_Address(&head);

    Insert(&head, 12);
    Insert(&head, 67);
    Insert(&head, 56);
    Insert(&head, 16);
    Insert(&head, 25);
    Insert(&head, 37);
    Insert(&head, 22);
    Insert(&head, 29);
    Insert(&head, 15);
    Insert(&head, 47);
    Insert(&head, 48);
    Insert(&head, 34);

    Show(&head);

    Del(&head, 25);
    Del(&head, 12345);
    Show(&head);

    return 0;
}

.h

#pragma once

typedef int ELEM_TYPE;
//链地址法有效节点结构体设计：
typedef struct List_Node
{
	ELEM_TYPE data;
	struct List_Node* next;
}List_Node;

#include "list.h"

//链地址法整个的辅助节点结构体设计：
#define INITSIZE 12
typedef struct List_address
{
	struct Node arr[INITSIZE];
}List_address;

//0.哈希函数
int Hash(ELEM_TYPE val);

//1.初始化
void Init_List_Address(List_address* pla);

//2.插入值
bool Insert(List_address* pla, ELEM_TYPE val);

//3.删除值
bool Del(List_address* pla, ELEM_TYPE val);

//4.查找值
struct Node* Search(List_address* pla, ELEM_TYPE val);

//5.打印
void Show(List_address* pla);