哈希表的线性探测C语言实现

哈希表的定义

哈希表（Hash Table）是一种基于哈希函数实现的高效数据结构，用于存储键值对（Key-Value）。它通过哈希函数将键（Key）映射到一个较小范围的整数值（通常是数组的索引），从而快速定位存储位置。哈希表的核心在于通过哈希函数实现快速的插入、查找和删除操作，其平均时间复杂度接近 O(1)，在处理大量数据时表现出极高的效率。

线性探测的定义

线性探测（Linear Probing）是解决哈希冲突的一种方法。当多个键通过哈希函数映射到同一个位置时，会发生冲突。线性探测通过依次检查后续位置（即线性地向后探测）来解决冲突。具体来说，如果位置 i 被占用，则检查位置 i+1，如果仍然被占用，则检查 i+2，依此类推，直到找到一个空闲位置来存储数据。

线性探测的特点

1. 高效性：

   • 哈希表的插入、查找和删除操作的平均时间复杂度接近 O(1)，在数据量较大时，性能优势明显。

   • 线性探测通过简单的线性扫描解决冲突，实现逻辑简单，易于理解。

2. 动态性：

   • 哈希表可以根据数据量动态调整大小。当负载因子（即表中已存储的元素数量与表容量的比值）达到一定阈值时，可以通过扩容操作增加表的容量，从而保持高效的性能。

   • • 聚集问题：

       线性探测的一个主要缺点是容易产生聚集（Clustering）。当多个键映射到相邻的位置时，线性探测会导致大量连续的位置被占用，从而增加后续插入和查找的开销。

     • 例如，如果多个键映射到同一个位置，线性探测会依次检查后续位置，导致大量连续的位置被占用，形成“聚集”。

3. 简单性：

   • 线性探测的实现逻辑简单，不需要复杂的数学运算或额外的数据结构支持。它通过简单的线性扫描解决冲突，易于实现和维护。

线性探测的实现

以下是线性探测在哈希表中的实现逻辑：

1. 插入操作：

   • 计算键的哈希值，确定初始位置。

   • 如果该位置已被占用，则依次检查后续位置，直到找到空闲位置。

   • 将键值对存储到空闲位置，并更新表的大小。

2. 查找操作：

   • 计算键的哈希值，确定初始位置。

   • 如果该位置的键与目标键不匹配，则依次检查后续位置，直到找到目标键或空闲位置。

3. 删除操作：

   • 查找目标键的位置。

   • 删除目标键。

负载因子

负载因子（Load Factor）是衡量哈希表使用效率的一个重要指标，它定义为哈希表中已存储的元素数量与哈希表总容量的比值。负载因子的计算公式为：

负载因子=哈希表的总容量  /   已存储的元素数量​。

对于插入查找删除来说，都会涉及到向哈希数组后进行查找，负载因子小的时候，查找到的空白格快，所以我们会关注哈希表中的负载因子和容量。

下面是C语言实现的代码：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
typedef struct hashtab
{
    int *date;//数组指针
    int size;//现有数据的量
    int hk;//哈希函数
    double a;//负载因子
    int capacity;//总容量大小
}HASH;
HASH* hash_init(int Capacity,double a1);
int add(HASH *hash,int num);
int delete(HASH *hash,int num);
int serch(HASH *hash,int num);
int isfull(HASH *hash);
void expand(HASH *hash);
int main(int argc, char const *argv[])
{
    HASH *hash=hash_init(5,0.6);
    add(hash,1);
    add(hash,4);
    add(hash,14);
    add(hash,15);
    add(hash,11);
    add(hash,3);
    add(hash,10);
    add(hash,19);
    add(hash,13);
    add(hash,16);
    add(hash,22);
    add(hash,17);
    add(hash,26);
    add(hash,18);


    return 0;
}
HASH* hash_init(int Capacity,double a1)
{
    HASH *hash=malloc(sizeof(HASH));
    hash->hk=Capacity;//对13取余
    hash->size=0;
    hash->capacity=Capacity;
    hash->date=malloc(sizeof(int)*hash->capacity);
    memset(hash->date,-1,sizeof(int)*hash->capacity);
    hash->a=a1;
    return hash;
}
int add(HASH *hash,int num)
{
    printf("尝试存储%d: cap=%d\n", num,  hash->capacity);
    if (isfull(hash)==1)//如果负载因子超过目标值
    {
       expand(hash);//扩容
    }
    int pos=num%hash->hk;//取余作为哈希哈数
    int i=pos;
    if (hash->date[i]==-1)//如果目标位置没有数值，则则直接插入
    {
        hash->date[i]=num;
        hash->size++;
        printf("存储成功,size:%d\n",hash->size);
        return 1;
    }
    else//目标位置有数值，向下寻找空位置
    {
        do{
            if (hash->date[i]==-1)
            {
                hash->date[i]=num;
                hash->size++;
                printf("存储成功,size:%d\n",hash->size);
                return 1;
            }
            i=(i+1)%hash->hk;
        }while (i!=pos);//直到回到原位停止，表示没有空位，无法插入    
    }
    return -1;
}
int delete(HASH *hash,int num)
{
    int pos=num%hash->hk;//取余后的位置
    int i=pos;
    do//原位置是该数据则直接删除，如果没有就向后寻找
    {
        if (hash->date[i]==-1)return -1;
        if (hash->date[i]==num)
        {
            hash->date[i]=-1;
            hash->size--;
            return 1;
        }
        i=(i+1)%hash->hk;
    }while (i!=pos);//如果本位置没有
    return -1;
}
int serch(HASH *hash,int num)
{
    int pos=num%hash->hk;//取余后的位置
    int i=pos;
    do//原位置是该数据则直接返回，如果没有就向后寻找
    {
        if (hash->date[i]==-1)return -1;
        if (hash->date[i]==num)
        {
            return i;
        }
        i=(i+1)%hash->hk;
    }while (i!=pos);//如果本位置没有
    return -1;
}
int isfull(HASH *hash)
{
    double s=(double) hash->size/hash->capacity;//实际负载因子
    return s >= hash->a ? 1 : 0;//如果大于目标负载因子，返回1
}
void expand(HASH *hash) {
    int old_capacity = hash->capacity;
    int *old_date = hash->date;
    
    hash->capacity *= 2;
    hash->hk = hash->capacity; // 更新哈希函数参数
    hash->date = malloc(sizeof(int) * hash->capacity);
    memset(hash->date, -1, sizeof(int) * hash->capacity);//重新分配空间
    hash->size=0;
    // 重新插入所有元素，手动更新size
    for (int i = 0; i < old_capacity; i++) {
        if (old_date[i] != -1) //旧数组位置不为空
        {
            int pos = old_date[i] % hash->hk;
            int j = pos;
            while (hash->date[j] != -1) {
                j = (j + 1) % hash->hk;
            }//找到可以插入的位置
            hash->date[j] = old_date[i];//插入
            hash->size++;//更新大小
        }
    }
    printf("扩容，新容量：%d\n", hash->capacity);
    free(old_date);//释放旧空间
}

运行结果：

因为我们的大小更新是在插入以后，所以对负载因子的计算是之后一次的。

本结果主要关注扩容，大家可以试一下其他功能。