数据结构_哈希表(C语言)

已于 2022-08-04 01:39:37 修改
阅读量1w 收藏 408
点赞数 69
分类专栏： 数据结构与算法（C语言） 文章标签： 数据结构 c语言 哈希表
于 2022-08-04 01:28:35 首次发布
我不能死我还要学习！(>_<)
本文链接：https://blog.csdn.net/qq_44625774/article/details/126065266
版权

数据结构总目录

本章目录

哈希表

哈希表中元素是由哈希函数确定的，将数据元素的关键字key作为自变量，通过一定的函数关系（称为哈希函数），计算出的值，即为该元素的存储地址。
在这里插入图片描述

1. 哈希函数

哈希函数：指将哈希表中元素的关键键值映射为元素存储位置的函数
常用哈希函数

  1. 直接定址法：直接取关键值为哈希表地址
  2. 数字分析法：取重复性低的几位数字作为哈希表地址
  3. 平方取中法：取关键字平方后的中间几位为哈希表地址
  4. 折叠法：将关键字分割成位数相同的几部分，然后取这几部分的叠加和（舍进位）作为哈希地址
  5. 除留余数法：取关键值的余数作为哈希表地址
  6. 随机数法：选择一个随机函数，取关键字的随机函数值为它的哈希地址

在不同场景中使用的哈希函数各不相同，也可以按照自己的需求设计哈希函数

1.1 源代码

#include <stdio.h>
#include <stdlib.h>
#define MaxSize 10
#define NullKey -32768

typedef int DataType;
typedef struct hashTable
{
    DataType *data;
    int count;  
}hashTable;

// 初始化哈希表
void InitHashTable(hashTable *H)
{
    // 分配空间
    H->data = (DataType *)malloc(MaxSize * sizeof(DataType));
    H->count = 0;

    // 初始化
    int i;
    for (i = 0; i < MaxSize; i++)
    {
        H->data[i] = NullKey;
    }
    printf("已初始化哈希表!\n");
}

// 定义哈希函数
int Hash(DataType key)
{
    //  除留余数法
    return key % MaxSize;
}

// 插入关键字
void InsertHashKey(hashTable *H, DataType key)
{
    // 根据哈希函数得到下标地址
    int address = Hash(key);
    printf("\n插入关键字 %d, 哈希地址 = %d\n", key, address);
    // 在目标地址存储数据
    if (H->data[address] == NullKey)
    {
        H->data[address] = key;
        H->count++;
        printf("插入下标地址[%d], 插入成功!\n\n", address);
    }
    else
    {
        printf("插入下标地址[%d], 发生冲突!\n\n", address);
    }
}

void DisplayHashTable(hashTable H)
{
    int i;
    printf("哈希表：\n");
    for (i = 0; i < MaxSize; i++)
    {
        printf("%d\t", i);
    }
    printf("\n");
    for (i = 0; i < MaxSize; i++)
    {
        if (H.data[i] != NullKey)
        {
            printf("%d\t", H.data[i]);
        }
        else
        {
            printf("-\t");
        }
    }
    printf("\n\n");
}

int main()
{
    int i;
    DataType key;
    hashTable H;
    InitHashTable(&H);
    printf("构建哈希表:");
    for (i = 0; i < MaxSize; i++)
    {
        // 参考用例: 50 81 192 33 64 75 86 97 88 109
        scanf("%d", &key);
        InsertHashKey(&H, key);
    }
    DisplayHashTable(H);
    
    while (1)
    {
        int address;
        printf("查找关键字: ");
        scanf("%d", &key);
        address = Hash(key);
        // 查找结果
        if (H.data[address] == key)
        {
            printf("查找成功, 目标地址 = %d\n", address);
        }
        else
        {
            printf("查找失败\n");
        }
    }
    return 0;
}

1.2 测试结果

在这里插入图片描述

2. 哈希冲突

哈希冲突：两个关键字经过哈希函数处理后的结果都映射在同一地址位置上
而对于哈希表而言，无论哈希函数设计得有多精妙，都可能会发生冲突现象

例如插入序列：0 11 21 31 41 51 61 71 82 97

在这里插入图片描述
在这里插入图片描述

2.1 开放地址法

开放地址法：发生冲突时，寻找下一个空的哈希地址
其中查找下一个空的哈希地址的常用方法包括【线性探测法】和【二次探测】

  • 线性探测法：每次向后移动d个位置（0 < d < MaxSize - 1）
  • 二次探测法：每次向后移动12、22、32… d2个位置
2.1.1 源代码
#include <stdio.h>
#include <stdlib.h>
#define MaxSize 10
#define NullKey -32768

typedef int DataType;
typedef struct hashTable
{
    DataType *data;
    int count;  
}hashTable;

// 初始化哈希表
void InitHashTable(hashTable *H)
{
    // 分配空间
    H->data = (DataType *)malloc(MaxSize * sizeof(DataType));
    H->count = 0;

    // 初始化
    int i;
    for (i = 0; i < MaxSize; i++)
    {
        H->data[i] = NullKey;
    }
    printf("已初始化哈希表!\n");
}

// 定义哈希函数
int Hash(DataType key)
{
    //  除留余数法
    return key % MaxSize;
}

// 插入关键字
void InsertHashKey(hashTable *H, DataType key)
{
    // 根据哈希函数得到下标地址
    int address = Hash(key);
    printf("\n插入关键字 %d, 哈希地址 = %d\n", key, address);
    int d = 1;
     // 若发生冲突则寻找下一个位置
    while (H->data[address] != NullKey)
    {
        printf("插入下标地址[%d], 发生冲突\n", address);
        // 1. 线性探测法
        address = (address + d) % MaxSize;
        
        // 2. 二次探测法
        // address = (address + d * d) % MaxSize; d++;
    }
    // 在最终地址存储数据
    H->data[address] = key;
    H->count++;
    printf("插入下标地址[%d], 插入成功\n\n", address);
}

// 查找关键字
int SearchHashKey(hashTable H, DataType key) 
{
    int address = Hash(key);
    int p = address;
    // 查找关键字
    while (H.data[p] != key)
    {
        // 线性探测
        p = (p + 1) % MaxSize;
        // 指针遍历到空数据，或者指针回到原位置，则代表查找失败
        if (H.data[p] == NullKey || p == address)
        {
            return -1;
        }
    }
    return p;
}

void DisplayHashTable(hashTable H)
{
    int i;
    printf("哈希表：\n");
    for (i = 0; i < MaxSize; i++)
    {
        printf("%d\t", i);
    }
    printf("\n");
    for (i = 0; i < MaxSize; i++)
    {
        if (H.data[i] != NullKey)
        {
            printf("%d\t", H.data[i]);
        }
        else
        {
            printf("-\t");
        }
    }
    printf("\n\n");
}

int main()
{
    int i;
    DataType key;
    hashTable H;
    InitHashTable(&H);
    printf("构建哈希表:");
    for (i = 0; i < MaxSize; i++)
    {
        // 参考用例: 50 81 191 32 65 75 9 97 88 109
        scanf("%d", &key);
        InsertHashKey(&H, key);
    }
    DisplayHashTable(H);

    while (1)
    {
        int address;
        printf("查找关键字: ");
        scanf("%d", &key);    
        // 查找关键字地址
        address = SearchHashKey(H, key);
        if (address != -1)
        {
            printf("查找成功, 目标地址 = %d\n", address);
        }
        else
        {
            printf("查找失败\n");
        }
    }
    return 0;
}
2.1.2 测试结果

在这里插入图片描述
在这里插入图片描述

2.2 拉链法

拉链法：哈希表的每个地址下都是链表结构，当发生冲突时，可将冲突数据存入链表中

  • 如下图：关键字【1】和【21】、【31】、【41】、【51】在除留取余法中均会发生冲突，则只需要将冲突数据插入冲突地址下的链表即可。

在这里插入图片描述

2.2.1 源代码
#include <stdio.h>
#include <stdlib.h>
#define MaxSize 10
#define NullKey -32768

typedef int DataType;
// 链表结点
typedef struct LNode
{
    DataType data;
    struct LNode *next;
}LNode, *LinkList;
// 哈希表
typedef struct hashTable
{
    LinkList list;
    int count;  
}hashTable;

// 初始化哈希表
void InitHashTable(hashTable *H)
{
    // 分配多个链表头结点空间
    H->list = (LNode *)malloc(MaxSize * sizeof(LNode));
    H->count = 0;

    // 初始化链表头结点（头结点存储初始值，链表后序结点存储冲突值）
    int i;
    for (i = 0; i < MaxSize; i++)
    {
        H->list[i].data = NullKey;
        H->list[i].next = NULL;
    }
    printf("已初始化哈希表!\n");
}

// 定义哈希函数
int Hash(DataType key)
{
    //  除留余数法
    return key % MaxSize;
}

// 插入关键字
void InsertHashKey(hashTable *H, DataType key)
{
    // 根据哈希函数得到下标地址
    int address = Hash(key);
    printf("\n插入关键字 %d, 哈希地址 = %d\n", key, address);
    
    if(H->list[address].data == NullKey)
    {
        // 若未发生冲突，则直接赋值给头结点
        H->list[address].data = key;
        printf("插入下标地址[%d], 插入成功!\n\n", address);
    }
    else
    {
        // 若发生冲突，则在该头结点的链表下进行头插
        // 创建新结点
        LNode *s;
        s = (LNode *)malloc(sizeof(LNode));
        s->data = key;
        // 头插法插入
        s->next = H->list[address].next;
        H->list[address].next = s;
        
        printf("插入下标地址[%d], 发生冲突! 已插入该地址的链表下\n\n", address);
    }
    H->count++;
}

// 查找关键字
LNode* SearchHashKey(hashTable H, DataType key) 
{
    int address = Hash(key);
    // 根据哈希地址获取对应链表的头结点
    LNode *p = &H.list[address];
    // 在链表中查找关键字
    while (p != NULL && p->data != key)
    {
        // 线性探测
        p = p->next;
    }
    return p;
}

void DisplayHashTable(hashTable H)
{
    int i;
    printf("哈希表：\n**********************************\n");
    for (i = 0; i < MaxSize; i++)
    {
        printf("%d\t", i);
    }
    printf("\n");

    LNode *p;
    int j, k = 0, flag = 1;
   
    while (flag)
    {
        flag = 0;
        for (i = 0; i < MaxSize; i++)
        {
            j = 0;
            p = &H.list[i];
            while (j < k && p)
            {
                p = p->next;
                j++;
            }
            if (p && p->data != NullKey)
            {
                printf("%d\t", p->data);
                flag = 1;
            }
            else
            {
                printf(" \t");
            }
        }
        k++;
        printf("\n");
    }
    printf("*********************************\n");
}

int main()
{
    int i;
    DataType key;
    hashTable H;
    InitHashTable(&H);
    printf("构建哈希表:");
    for (i = 0; i < MaxSize; i++)
    {
        // 参考用例: 50 81 191 32 65 75 9 97 88 109
        scanf("%d", &key);
        InsertHashKey(&H, key);
    }
    DisplayHashTable(H);

    while (1)
    {
        LNode *result;
        printf("查找关键字: ");
        scanf("%d", &key);    
        // 查找关键字地址
        result = SearchHashKey(H, key);
        if (result != NULL)
        {
            printf("查找成功, 目标地址 = %x\n", result);
        }
        else
        {
            printf("查找失败\n");
        }
    }
    return 0;
}
2.2.2 测试结果

在这里插入图片描述
在这里插入图片描述

哈希表操作（c语言版）
11-24
////采用除留余数法定义哈希表，哈希表长度为10，哈希函数为H(key)=key%13。产生冲突时采用线性探测法实现下面要求的功能。 ////（1）初始化哈希表,置空哈希表 ////（2）在哈希表中查找元素 ////（3）在哈希表中插入元素 ////（4）输出哈希表中所有元素 ////（5）建立Hash表
哈希表的建立与运用C语言实现哈希表的建立与运用C语言实现
12-12
哈希表的建立与运用C语言实现哈希表的建立与运用C语言实现哈希表的建立与运用C语言实现哈希表的建立与运用C语言实现哈希表的建立与运用C语言实现
【数据结构】哈希表——C语言
Shun_Hua的博客
06-14 9560
主要介绍C语言提供的哈希函数。
【C语言数据结构】之哈希表
weixin_61276540的博客
09-24 1256
本文主要讲解哈希表的概念和实现，尤其是解决哈希冲突时候所采用的链地址法。我们主要还是要实现出代码，理解和代码共存。
哈希表（C语言）
qq_45524140的博客
12-13 3201
哈希表 ​ 哈希表又称散列表，是一种是“key-value"形式存储的数据结构。即将key映射到表上的一个单元，从而实现快速查找等操作，这个映射操作就叫散列，具体通过散列函数实现相应的映射。根据key的形式，散列的形式多种多样，这里以正整数为例，常用的散列函数为： Hash(Key)=Key%TableSize Hash(Key) = Key \% TableSize Hash(Key)=Key%TableSize ​ TableSize为表长，一般情况下，我们希望一个元素能唯一对应表上的一个单元，但是这是
哈希表-数据结构(C语言)
热门推荐
weixin_44681349的博客
05-15 1万+
哈希表 什么是哈希表 我们在网站上注册账号时，当填好用户名后，系统都会判断用户名是否已被使用，如果已被使用，系统就会提示该用户名已被注册。那么系统是如何检测用户名是否被使用的呢？我们能想到的最简单的方法就是逐个比较，但是如果用户名有很多，查找效率就显得很低。还有一种方法就是把用户名按字典序排序进行二分查找，这个方法的效率的确是高了很多，可是前提是用户名是有序的，而有些时候我们并不能将用户名进行排序。那么还有没有更好的方法呢？ 我们可以用 哈希表 来解决这个问题。哈希表又叫散列表，关键值通过哈希函数映射到数组
C语言哈希表
qq_51214556的博客
11-22 8412
1.概念 哈希表：关键字与存储位置有函数关系的表。只要给出关键字的值，我们就可以计算出该关键字在哈希表中的存储位置，方便查找。 冲突：两个或多个不同的关键字根据函数关系计算得到的存储位置一致。关键字个数大于存储位置的个数，就不可避免产生冲突，所以我们需要寻找处理冲突的方法。 同义词：产生冲突的关键字互称同义词。 2.哈希表的构造方法 随机关键字在哈希表上分布的越均匀，发生冲突的概率也越低，这是构造哈希表要遵循的原则，还有计算的函数要尽量简单，不然会拖慢运行速度。 设关键字为key，H(k
hashtab2_C语言_哈希表删除、添加、寻找_codeblocks_
10-04
哈希表是一种高效的数据结构，它通过特定的函数（哈希函数）将数据映射到一个固定大小的数组中，以此实现快速的查找、插入和删除操作。在C语言中，我们可以手动构建哈希表来处理这些操作。Code::Blocks是一款流行的...
haxi.rar_C语言 哈希表_哈希表
09-24
哈希表是一种高效的数据结构，它通过特定的函数——哈希函数，将数据映射到一个固定大小的数组中，以此实现快速的插入、查找和删除操作。在C语言中，哈希表的实现通常涉及指针、动态内存分配以及自定义的哈希函数。 ...
Hash_Table.rar_C语言 哈希表_Table_数据结构代码
07-15
哈希表，数据结构，完整代码，值得学习。C++语言
专家讲述C语言数据结构.rar_c 数据结构_c语言数据结构_数据结构
09-24
C语言数据结构主要包括数组、链表、栈、队列、树、图、哈希表等多种类型。数组是最基本的数据结构，它允许我们以固定大小的方式存储相同类型的元素。链表则在内存中非连续存储，通过指针连接元素，适合频繁插入和...
数据结构哈希表C语言
01-03
很简单的一个.........................................................
用C语言实现一个简单的哈希表(hash table)
05-07
这个小程序实现了哈希表的主要内容。有哈希函数、冲突避免，实现了插入和查找。主要是作为一个教学的例子存在。 本程序用Visual Studio 2005实现。
哈希表查找(C语言实现)
03-24
NULL 博文链接：https://touch-2011.iteye.com/blog/1090305
哈希表的c语言实现1
03-01
哈希表的哈希取余法和链表地址法来实现哈希表的基本操作。。。
数据结构实验五哈希表设计c语言
04-25
哈希表是一种常用的数据结构，它可以快速地存储和检索数据。在本实验中，我们设计了一种哈希表，以学生姓名为关键字，存储学生信息，并实现了查找学生信息的功能。 哈希表的构造方法 在本实验中，我们使用了链地址...
哈希表的C语言实现
kingCSUN的博客
05-22 2266
int size;这段代码中用typedef关键字定义了哈希表的结构体。结构体的名称是：HashTable代码：HashNode** table;定义了一个指针数组table，用于存储哈希表中各个桶的头指针。每个桶可以看作是一个链表的头节点，存储哈希表中所有散列到该桶中的键值对。size是一个整数，表示哈希表的大小，即哈希表中的桶的数量。
C语言-哈希表
最新发布
qq_51097294的博客
10-18 624
了解c语言哈希表的常见用法
c语言哈希表大话数据结构
09-12
哈希表是一种高效的数据结构，它能够在平均情况下以常数时间O(1)进行插入、删除和查找操作。在C语言中，我们可以使用哈希表来解决一些常见的问题，比如查找一个元素或者统计元素出现的频率。 在实现哈希表时，我们需要以下几个关键组成部分： 1. 哈希函数：哈希函数将输入的数据映射到哈希表中的某个位置，它应该具备良好的分布性，即使数据分布不均匀，也能使得元素尽可能均匀地散列到不同的槽位中。 2. 数组：哈希表通常使用一个数组来存储数据，数组的大小可以根据实际情况进行调整。每个槽位可以存储一个元素或者一个指向链表/红黑树等数据结构的指针，用于解决哈希冲突。 3. 冲突处理：由于不同的元素可能被映射到相同的槽位上，所以我们需要解决冲突的问题。常见的解决方法有开放地址法和链地址法。开放地址法会寻找下一个可用的槽位，直到找到一个空闲位置，而链地址法则使用链表或其他数据结构将冲突的元素串联起来。 使用C语言实现哈希表时，我们可以先定义一个结构体来表示哈希表的每个槽位，然后使用数组来存储这些结构体。结构体可以包含键值对等信息，以及指向下一个元素的指针（用于链地址法）。然后，我们可以根据需要实现插入、删除和查找等操作，使用哈希函数将元素映射到相应的位置，并根据具体的冲突处理方式解决冲突。 总之，哈希表是一种非常实用的数据结构，它在处理大量数据时能够提供高效的查找和操作效率。在C语言中，我们可以根据具体需求实现自己的哈希表，或者使用已有的开源库来简化开发过程。
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小-黯

免费的，尽力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值