C语言数据结构与算法笔记（散列表）

已于 2024-03-21 20:27:39 修改
阅读量1.9k 收藏 54
点赞数 29
文章标签： 散列表 笔记 数据结构
于 2024-03-09 20:17:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/DarlingLSA/article/details/136507985
版权

散列表

散列也称哈希，直接寻址

散列查找

将参与检索的数据与散列值（哈希值）关联起来，生成便于搜索的数据结构。将一堆数据进行哈希函数计算，下次查找数据时，再次计算哈希值即可查找到对应的元素。

散列函数

哈希函数对目标计算一个其对应的哈希值，哈希函数对同一个目标计算的结果是一样的。

散列表

利用哈希值的特性，设计一个全新表结构，哈希表（散列表）。对应元素的关键字（整数）提供给哈希函数可进行计算。
一般有进行取模操作，哈希表的长度是多少，模就是多少。
在这里插入图片描述
在这里插入图片描述
代码实现
用数组功能实现哈希表
初始化

#define SIZE 9

typedef struct Element
{
    int key;
} * Element;

typedef struct HashTable
{
    Element * table; 
} * HashTable;

void init(HashTable hashTable)
{
    hashTable->table = malloc(sizeof(struct Element) * SIZE);
    for(int i = 0; i < SIZE; ++i)
    {
        hashTable->table[i] = NULL; // 将哈希表的每个元素初始为空
    }
}

// 哈希函数
int hash(int key) 
{
    return key % SIZE;
}
// 插入
void insert(HashTable hashTable, Element element)
{
    int hashCode = hash(element->key);
    hashTable->table[hashCode] = element; // 将哈希值放入到哈希表中
}
// 查找
_Bool find(HashTable hashTable, int key)
{
    int hashCode = hash(key);
    if(hashTable->table == NULL)
    {
        return 0;
    }
    else
    {   // 计算hash表上的元素值是否等于
        return hashTable->table[hashCode]->key == key;
    }
}
// 创建元素
Element create(int key)
{
    Element element = malloc(sizeof(struct Element));
    element->key = key;
    return element;
}

测试，main函数中，查看哈希表，检查是否找到元素

    struct HashTable table;
    init(&table);
    insert(&table, create(10));
    insert(&table, create(7));
    insert(&table, create(13));
    insert(&table, create(19));

    for(int i = 0 ; i < SIZE;++i)
    {
        if(table.table[i])
        {
            printf("%d ", table.table[i]->key);
        }
        else
        {
            printf("NULL ");
        }
    }
    printf("%d\n", find(&table,1));
    printf("%d\n", find(&table,13));

哈希冲突

哈希函数计算得到一个目标的哈希值，但可能出现哈希值相同的情况，称为哈希碰撞

线性探测法

第一次发生哈希冲突，找空位。 h i ( k e y ) = ( h ( k e y ) + d i ) h_i(key)=(h(key)+d_i)%TableSize hi​(key)=(h(key)+di​)，其中 d i d_i di​是随着哈希冲突次数增加而增加的量。出现哈希冲突， d i d_i di​自增，继续寻找下一个空位，再次计算哈希值，得到对应位置。 d i d_i di​默认为0

// 插入(考虑哈希冲突) 线性探测法
void insert(HashTable hashTable, Element element)
{
    int hashCode = hash(element->key);
    int cnt = 0;
    while(hashTable->table[hashCode] && cnt < SIZE) // 如果发生哈希冲突，继续寻找下一个位置
    {
        hashCode = hash(element->key + +cnt);
    }
    hashTable->table[hashCode] = element; // 将哈希值放入到哈希表中
}
// 查找
_Bool find(HashTable hashTable, int key)
{
    int hashCode = hash(key), cnt = 0; // 计算哈希值
    const int startIndex = hashCode; // 记录起始位置，转一圈回来就结束
    do
    {
        if(hashTable->table[hashCode]->key == key)
        {
            return 1;
        }
        hashCode = hash(key + ++cnt);
    }while(startIndex != hashCode && hashTable->table[hashCode]); // 没找到继续找
    return 0;
}

考虑哈希冲突，进行线性观测法，且考虑当哈希表满时，退出

但线性观测法删除元素时比较麻烦，可能会影响前面的查找操作。
在这里插入图片描述
考虑删除一个元素可能会导致原有结构意外截断，需要对位置进行标记，表示之前有过的元素被删除了。在查找时，发现被删除的位置曾经有过元素，依然需继续往后寻找
在这里插入图片描述
也可采用二次探测再散列法处理哈希冲突。可以向两个方向去寻找。查找的增量序列为: 1 2 、 − 1 2 、 2 2 、 − 2 2 . . . 1^2、-1^2、2^2、-2^2... 12、−12、22、−22...。左右反复查找可提高利用率

链地址法

哈希冲突，链表形式。但链表变得长时，查找效率也会变低，考虑转换为平衡二叉树或者红黑树。
在这里插入图片描述

#define SIZE 9

typedef struct LNode // 节点定义
{
    int key;
    struct LNode * next;
} * Node;

typedef struct HashTable
{
    struct LNode * table; // 数组存放头结点
} * HashTable;
// 初始化
void init(HashTable hashTable)
{
    hashTable->table = malloc(sizeof(struct LNode) * SIZE);
    for(int i = 0 ; i < SIZE; ++i)
    {
        hashTable->table[i].key = -1; // 将头结点设为-1
        hashTable->table[i].next = NULL;
    }
}
// 哈希函数
int hash(int key) 
{
    return key % SIZE;
}
// 创建节点
Node createNode(int key)
{
    Node node = malloc(sizeof(struct LNode));
    node->key = key;
    node->next = NULL;
    return node;
}

插入

// 插入
void insert(HashTable hashTable, int key)
{
    int hashCode = hash(key);
    Node head = hashTable->table + hashCode;
    // Node head = &hashTable->table[hashCode];
    while(head->next)
    {
        head = head->next; // 找到下一个为空的
    }
    head->next = createNode(key); // 插入节点
}

// 查找元素
_Bool find(HashTable hashTable, int key)
{
    int hashCode = hash(key);
    Node head = hashTable->table + hashCode;
    while(head->next && head->key != key)
    {
        head = head->next;
    }
    return head->key == key; // 直接找对应的
}

测试

    struct HashTable table;
    init(&table);
    insert(&table, 10);
    insert(&table, 19);
    insert(&table, 20);
    printf("%d\n", find(&table,20));
    printf("%d\n", find(&table,17));
    printf("%d\n", find(&table,19));
散列表习题
  1. 设有一组记录的关键字wei{19,14,23,1,68,20,84,27,55,11,10,79}，用链地址法构造散列表，散列函数为H(key)=key MOD 13，散列地址为1的链中有多少个记录
  2. 设哈希表长为14，哈希函数为H(key)=key%11，表中已有数据的关键字为15，38，61，84.现将关键字为49元素加入到散列表中，二次探测再散列解决冲突，则放入的位置是
    按照二次散列的增量序列计算下一个位置
  3. 选取哈希函数H(key)=(key*3)%11，用线性探测散列法和二次探测再散列处理哈希冲突。试在0~10的散列地址空间中，对关键字序列{22,41,53,46,30,13,1,67}构建哈希表，求等概率情况下查找成功的平均查找长度。其中平均查找长度为表中每一个元素需要查找次数之和的平均值。
    线性探测散列的平均查找次数
    在这里插入图片描述
    ASL = 2
    二次探测再散列的平均查找次数
    在这里插入图片描述
    ASL=1.875
算法实战
  1. 两数之和
    给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。
    假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。
    可以按任意顺序返回答案。

在这里插入图片描述
暴力枚举，直接让每个数取寻找与之匹配的数

// 返回计算两数之和
int * result(int i, int j, int * returnSize)
{
    *returnSize = 2;
    int * result = malloc(sizeof(int) * 2);
    result[0] = i;
    result[1] = j;
    return result;
}

int* twoSum(int* nums, int numSize, int target, int* returnSize)
{
    for(int i = 0; i < numSize;++i) // 遍历数组每一个数
    {
        for(int j = 0; j < numSize; ++j) // 二次遍历找目标元素
        {
            if(i == j) // 不找自身，跳过循环
            {
                continue;
            }
            else
            {
                if(nums[i] + nums[j] == target)
                {
                    return result(i, j, returnSize);
                }
            }
        }
    }
    return NULL;
}

散列表，每遍历一个数都将其存放到散列表中，遇到与匹配的数时，只需要遍历一次就行。

// 散列表
#define SIZE 128

typedef int K;
typedef int V;

typedef struct LNode // 节点定义
{
    K key; // 存入关键字和下标
    V value;
    struct LNode * next;
} * Node;

typedef struct HashTable
{
    struct LNode * table; // 数组存放头结点
} * HashTable;

// 初始化
void init(HashTable hashTable)
{
    hashTable->table = malloc(sizeof(struct LNode) * SIZE);
    for(int i = 0 ; i < SIZE; ++i)
    {
        hashTable->table[i].key = -1; // 将头结点设为-1
        hashTable->table[i].value = -1;
        hashTable->table[i].next = NULL;
    }
}
// 创建节点
Node create(K key, V value)
{
    Node node = malloc(sizeof(struct LNode));
    node->key = key;
    node->value = value;
    node->next = NULL;
    return node;
}

将插入的元素放入散列表，（插入节点），查找下一个元素是否匹配，匹配则直接返回结果，否则放入散列表，下一个元素

// 哈希函数
int hash(unsigned int key) // 遇到负数将其转化为无符号数
{
    return key % SIZE;
}

// 插入
void insert(HashTable hashTable, K key, V value)
{
        int hashCode = hash(key);
    Node head = hashTable->table + hashCode;
    // Node head = &hashTable->table[hashCode];
    while(head->next)
    {
        head = head->next; // 找到下一个为空的
    }
    head->next = createNode(key, value); // 插入节点
}
// 查找元素
_Bool find(HashTable hashTable, int key)
{
    int hashCode = hash(key);
    Node head = hashTable->table + hashCode; // 定位到对应位置
    while(head->next && head->next->key != key) // 有没有下一个节点，并且下一个节点不是key
    {
        head = head->next;
    }
    return head->next;
}
int * result(int i, int j, int * returnSize)
{
    *returnSize = 2;
    int * result = malloc(sizeof(int) * 2);
    result[0] = i;
    result[1] = j;
    return result;
}

int* twoSum(int* nums, int numSize, int target, int* returnSize)
{
    struct HashTable table;
    init(&table);

    for(int i = 0 ; i < numSize; ++i)
    {
        Node node = find(&table, target - nums[i]); // 直接在哈希表中寻找匹配的，
        if(node) // 如果该数匹配，则直接返回结果
        {
            return result(i, node->value, returnSize);
        }
        else // 未找到则将该数放进散列表，继续找下一个是否匹配
        {
            insert(&table, nums[i], i);
        }
    }
    return NULL;
}
LucienLSA
关注
  • 29
    点赞
  • 踩
  • 54
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C语言实现散列表（哈希Hash表)实例详解
01-01
C语言实现散列表（哈希Hash表) 实例代码： //散列表查找算法（Hash） #include #include #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 #define SUCCESS 1 #define UNSUCCESS 0 #define HASHSIZE 7 #define NULLKEY -32768 typedef int Status; typedef struct { int *elem; //基址 int count;
【数据结构】哈希表——C语言
Shun_Hua的博客
06-14 6681
主要介绍C语言提供的哈希函数。
《算法导论》学习（十四）----散列表（哈希表）（C语言）
weixin_52042488的博客
09-16 755
本文主要讲解散列表（也可以称作哈希表）的相关内容，并且重点讲解了散列函数，以及用C语言是实现了链式散列表
数据结构入门7-2（散列表）
w_pab的博客
06-02 1284
散列表的基本概念 散列函数的构造方式 构造散列函数的常见方法 1. 数字分析法 2. 平方取中法 3. 折叠法 4. 除留余数法 处理冲突的方法 开放地址法 链地址法 散列表的查找
【C语言】散列表（哈希表）
weixin_44348253的博客
11-28 814
简述散列表，以及C语言代码实现
【C语言数据结构】散列表（哈希表）原理和代码
m0_61440484的博客
02-09 1317
散列表（哈希表）原理和C语言代码，作为备考数据结构课程笔记，后续会不断丰富
数据结构——学习笔记——入门必看【建议收藏】
热门推荐
刘鑫磊
02-09 39万+
（2）静态查找表&动态查找表的区别用法【顺序查找-线性查找-折半查找-二分查找-有序表查找-插值查找-斐波那契查找-索引顺序表查找-分块查找】单独使用顺序存储结构（即数组）无法很好地实现树的存储概念，不过如果充分利用顺序存储和链式存储结构的特点，则完全可以实现对数的存储结构的表示。深度为 2，则至多只有 3 个结点：根结点，根结点的左子树，根结点的右子树···指的是这样一个数列：1、1、2、3、5、8、13、21、……（3）四中常见的多路查找树【2-3 树$2-3-4 树$B 树$B+ 树】的区别用法。
C语言数据结构知识点小结(全）
Shen Mu Xin's Blog
07-14 3万+
C语言数据结构小结，B站青岛大学-王卓授课笔记
C语言描述的数据结构与算法教程
09-23
用C语言描述的数据结构与算法的入门教程，同时还介绍了部分机器学习的算法，另附带演示软件。
C语言数据结构与算法完整版资料.ppt
11-14
C语言数据结构与算法完整版资料.ppt
数据结构与算法 c语言 线性表-静态链表
04-27
数据结构与算法 c语言 线性表-静态链表 静态链表源码
C语言数据结构与简单的算法
09-18
笔记 链式结构也是一种物理结构 链式物理结构由多个结构体存储区构成, 任何两个结构体存储区之间可以用 指针连接 链式物理结构中的每个结构体存储区叫做 一个节点 单向线性链式物理结构是最简单的链式 物理...
常见数据结构与算法C语言实现
05-04
# 常见数据结构与算法C语言实现 内容包含常见基本数据结构实现（C语言版）如各自排序、链表、栈、队列、各种树以及应用、图算法、字符串匹配算法、回溯、并查集等 以及包含各个数据结构常见算法题的解答（C语言版...
C语言写一个散列表
微小冷的学习笔记
12-30 2547
文章目录快速理解散列表散列函数防撞 快速理解散列表 散列表，就是下标可以为字母的数组。 假设现有一个数组int a[100]，想查找其中第40个元素，则直接输入a[40]就可以了，时间复杂度为O(1)O(1)O(1)。 问题在于，当下标不是数字，而是一个字符串的时候，可能需要一个超大的空间才能将所有下标妥善地存放在特定的位置。例如，若以大小写字母作为下标索引，那么一位就需要预留52个空间，10位就需要521052^{10}5210这么大的空间，根本没有设备可以满足。 好在，521052^{10}5210这么
Linux学习笔记（二）
weixin_42515203的博客
05-28 332
Linux的学习笔记
Vue3实战笔记（52）—Vue 3封装持仓分析饼图
最新发布
山花的博客
05-30 470
接上文，封装持仓分析饼图。封装好几个组件，用于后续开发。把忧愁煮成茶，让它在心间慢慢沉淀，剩下的，便是清甜的回味。
强化学习——学习笔记
qq_52302919的博客
05-27 1308
强化学习问题通常可以建模为一个马尔可夫决策过程，包括以下几个要素：1、状态集合 (State Set)：S；2、动作集合 (Action Set)：A；Ps′∣saPs′∣sa，描述在状态s下执行动作a后转移到状态s′s^′s′的概率；Rsas′Rsas′，描述在状态s 下执行动作a并转移到状态s′后获得的奖励。πa∣sπ (a∣s)πa∣s，描述智能体在状态s下选择动作a 的概率。
Python图形界面(GUI)Tkinter笔记（十四）：Entry与Button的碰撞（1）
肥辉的学习笔记
05-29 220
用功能按钮(Button)、单行文本输入框(Entry)、文本框内容读取(get)实现一个极简易的加法运算，及与其他控件的交互，提高体验，主要体现其人机交互的意义。因为Entry()文本输入框没有限制输入内容属性的参数，它是把所有的输入都视作它特有的一个类属性，所以用get()方法读取出来是一个字符串而这字符串可包括字母或其它符号。因此我们必须对其进行判断后再计算，若直接计算可能会出现不可预料的错误。这里用了try...except..进行了简单的错误判断处理。
c语言数据结构与算法
09-10
C语言数据结构与算法是指在C语言编程中，使用不同的数据结构和算法来解决问题。数据结构是指在计算机中存储和组织数据的方式，而算法是解决问题的一系列计算步骤。在C语言中，我们可以使用各种数据结构和算法来处理...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值