C C++手撕哈希表详解_手撕哈希表c++

于 2024-09-22 11:58:58 发布
阅读量822 收藏 30
点赞数 12
文章标签： c语言 c++ 散列表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_87256382/article/details/142434474
版权

既然要讲位运算，那么我先讲讲一个二进制串。
在只有一个 1 的二进制串里面，我们对它再减去 1 的时候，我们很快得到它的低位掩码。
比如：
0001000 - 1 = 0000111，得到的 0000111 有什么用处呢？

如果我们把一个 hashcode 和这个数进行按位与，则得到的结果肯定是介于 000~111 之间，也就是 0~7 之间，这个时候我们思考一下，如果把这个 0001000 看做是桶数组的长度，那么这个按位与的结果就可以当做需要存入的桶的具体位置了。

基于这个理论，我们只要桶数组长度是 2的倍数 则 hashcode%size 可用 hashcode&(size-1) 来替代。

这样做有以下好处：

  1. 位运算的性能更好。
  2. 便于控制 hashcode 最终得出的结果，有些时候我们得到的 hashcode不够均匀 高位的1比较多，而低位的1比较少，这个时候可以利用 hashcode^(hashcode>>16) 进行一定程度的打散，而这个打散的过程我们一般把它叫做 扰动函数 。
哈希冲突

当出现键值运算结果得到的桶子位置是同一个的时候便产生了哈希冲突。

而解决哈希冲突的方案一般有以下三种：

链地址法
一旦发生哈希冲突，直接生成链表往后继续延伸。
开放地址法
简单来说就是给冲突的元素再在桶数组里找到一个空闲的位置。
而常用采用的方法有：

  1. 线性探查法: 从冲突的位置开始，依次判断下一个位置是否空闲，直至找到空闲位置。
  2. 平方探查法: 从冲突的位置x开始，第一次增加 1^2 个位置，第二次增加 2^2…，直至找到空闲的位置。
  3. 双散列函数探查法

…
再哈希法

再哈希法完全可以配备以上两类方法进行使用。

当然也可单独使用，单独使用的话就行配备多个哈希函数，一个不行的话换另一个哈希函数，直到不产生哈希冲突为止。

最终的选择：

而我们常用的是 链地址法 + 再哈希 ，为了能够尽量减少内存空间的使用，我们默认从容量为 16 的桶数组开始，一旦装入的键值对超过 capacity * factor 个时，我们进行一次两倍的（左移1位）扩容，而由于扩容会导致 capacity 改变，所以通过 哈希函数 + 与运算 得出的位置也会出错，故需要经过 再哈希 。

我们其实可以继续细想，我们左移一位后，得出的结果再减一，它也仅仅多出一位掩码，而我们的 hashcode 只要在这一位上为 0 则最后得到的桶位置不会有任何改变，只有在这一位上为 1 的才会发生改变，所以根据这个特点，Java 8 进行了一些优化，更厉害的优化方式在于，只要链比较长，它还会转红黑树（这就在我的能力范围之外了）。

以上内容参考的文章为：一个HashMap和面试官扯了半小时

HashMap实现

类型定义（键值对以及对应节点）

C

#define DEFAULT\_CAPACITY 16 //初始的表长
#define DEFAULT\_FACTOR 0.75f //初始的装载因子
/\*类型定义 和 装载因子初始化\*/
typedef int key\_t;
typedef int val\_t;
static const float factor = DEFAULT_FACTOR; //装载因子
typedef struct node {//每个哈希表的键值对
    key\_t key;
    val\_t val;
    struct node \*next;
} Node;

C++

全程用的泛型模板

哈希表的数据

C

typedef struct {
    size\_t size;       //记录已经存下的键值对数目
    size\_t capacity;   //记录表长
    Node \*\*buckets; //桶子：用于记录的哈希桶，桶子中每个元素是Node\*
} HashMap;

C++

初始化方法（构造方法）

C

HashMap \*init() {    //初始化得到一个哈希表
    HashMap \*ret = (HashMap \*) malloc(sizeof(HashMap));
    assert(ret != NULL);
    ret->size = 0;
    ret->capacity = DEFAULT_CAPACITY;
    ret->buckets = (Node \*\*) calloc(DEFAULT_CAPACITY, sizeof(Node \*));
    assert(ret->buckets != NULL);
    return ret;
}

C++

根据散列函数得到位置

C

static inline size\_t getHashcode(key\_t key) {
    return key ^ (key >> 16);//这是32位数的扰动函数
}

static inline size\_t getIndex(key\_t key, size\_t bucket_size) {//由于bucketsize一定是2的次方，所以size-1和key相与得到的就是下标
    return getHashcode(key) & (bucket_size - 1);
}

C++

put方法

C

void put(HashMap \*map, key\_t key, val\_t val) {
    assert(map != NULL);
    //判断是否需要扩容
    if (map->size >= map->capacity \* factor) resize(map);
    putVal(key, val, map->buckets, &map->size, map->capacity);
}



static void putVal(key\_t key, val\_t val, Node \*\*buckets, size\_t \*returnSize, size\_t bucketSize) {
    //获取位置
    size\_t index = getIndex(key, bucketSize);
    Node \*node = buckets[index];
    if (node == NULL) {//插入位置为空
        node = (Node \*) malloc(sizeof(Node));
        assert(node != NULL);
        node->val = val;
        node->key = key;
        node->next = NULL;
        buckets[index] = node;
        (\*returnSize)++;    //哈希表内的元素增加
        return;
    }
    //插入位置不为空，说明发生冲突，使用链地址法，遍历链表
    while (node != NULL) {
        //如果key相同就覆盖
        if (node->key == key) {
            node->val = val;
            return;
        }
        node = node->next;
    }
    //当前的key不在链表中，则插入链表头部
    Node \*newNode = (Node \*) malloc(sizeof(Node));
    assert(newNode != NULL);
    newNode->next = buckets[index];
    buckets[index] = newNode;
    (\*returnSize)++; //哈希表内元素增加
}

C++

扩容方法

C

static void resize(HashMap \*map) {
    map->capacity <<= 1;            //扩大两倍容量，相当于左移一位
    Node \*\*tmp = map->buckets;     //存下之前的内存地址
    map->buckets = (Node \*\*) calloc(map->capacity, sizeof(Node \*)); //重新分配
    assert(map->buckets != NULL);
    rehash(map, tmp);//重新哈希处理
    free(tmp);                                          //释放之前的内存
}


static void rehash(HashMap \*map, Node \*\*preTable) {//采取java1.7的方式进行rehash也就是最简单直接的直接重新哈希插入
    size\_t preCap = map->capacity / 2; //改变前的有效区域
    for (size\_t i = 0; i < preCap; i++) {
        if (preTable[i] != NULL) {//判断对应的key是否需要重新换位置,如果对最新掩码多出来的1敏感则需要rehash
            Node \*preNode;
            Node \*curNode = preTable[i];
            while (curNode != NULL) {
                preNode = curNode;
                curNode = curNode->next;
                insert(map, preNode);
            }
        }
    }
}

C++

get方法

C

val\_t \*get(HashMap \*map, key\_t key) {//前面的写好后，那么get就很好写了
    int index = getIndex(key, map->capacity);
    Node \*node = map->buckets[index];
    while (node != NULL) {
        if (node->key == key) {
            return &(node->val);
        }
        node = node->next;
    }
    return NULL;//没找到返回NULL指针
}

C++

C++标准中主要采用重载下标运算符的方式进行get。

完整代码

C完整代码
C++完整代码

测试：LeetCode 1.两数之和
  • 这效率在用C语言哈希表的方法里面应该是无敌的存在了。。。试了下比UT_HASH还要快一些☺

    再看看之前写的比较烂的哈希表的效率😂

    测试源码：
//
// Created by L\_B\_\_ on 2021/11/24.
//
//底层的表长都用2的次方，然后-1后可以得到低位掩码
//该设计理念急于java1.7的源代码，本来是想基于1.8的实现，
// 因为1.8巧妙太多，比如对rehash尽量能不动的就不动，再比如对于链比较长的结构直接转红黑树。可惜能力不能及
/\*\*
 \* 简单说明：static修饰的函数为单文件的中间委托功能函数，不对外公开
 \* 简单的功能函数介绍：
 \* init()得到一个默认表长的哈希表
 \* put()插入键值，内部自动进行内存的申请
 \* get()得到key对应的val的地址，若不存在该键值对返回NULL
 \* insert()外界已经分配好node的内存和key&val对，进行哈希运算后直接插入即可
 \* destroy()把整个哈希表牵扯的所有内存释放
 \* \*\*/
#include <assert.h>
#include <stdlib.h>
#ifndef MY\_TINY\_STL\_HASHMAP\_C\_H
#define MY\_TINY\_STL\_HASHMAP\_C\_H
#define DEFAULT\_CAPACITY 128 //初始的表长
#define DEFAULT\_FACTOR 0.75f //初始的装载因子
/\*类型定义 和 装载因子初始化\*/
typedef int key\_t;
typedef int val\_t ;
static const float factor = DEFAULT_FACTOR; //装载因子
typedef struct node{//每个哈希表的键值对
    key\_t key;
    val\_t val;
    struct node\* next;
}Node;
typedef struct {
    size\_t size;       //记录已经存下的键值对数目
    size\_t capacity;   //记录表长
    Node\*\* buckets; //桶子：用于记录的哈希桶，桶子中每个元素是Node\*
}HashMap;


/\*函数的声明\*/
HashMap\* init();
void put(HashMap\*,key\_t,val\_t);
void insert(HashMap\*,Node\*);                           //直接把已经分配好的内存插入哈希表
static void putVal(key\_t,val\_t,Node\*\*,size\_t\*,size\_t); //这个是put的委托函数,用于直接更新桶子，并更新HashMap的size
static inline size\_t getHashcode(key\_t );              //得到key对应的hashcode
static inline size\_t getIndex(key\_t,size\_t);           //通过桶的大小和key映射位置，算是包含了关键的哈希函数：由于C不支持泛型也就无法针对不同类型作出不同的哈希了，我这里默认key为int
static void resize(HashMap\*);                          //如果插入的元素过多，\*2进行重新哈希分配
static void rehash(HashMap\*,Node\*\*);                          //重新设置长度则需要重新哈希一些key的位置
val\_t\* get(HashMap\*,key\_t);                            //得到key对应的val
static void del\_nodes(Node\*);                          //把单个链表销毁
void destroy(HashMap\*);                                //把哈希表的内存销毁

/\*函数实现\*/
HashMap\* init(){    //初始化得到一个哈希表
    HashMap \* ret = (HashMap\*)malloc(sizeof(HashMap));
    assert(ret!=NULL);
    ret->size = 0;
    ret->capacity = DEFAULT_CAPACITY;
    ret->buckets = (Node\*\*)calloc(DEFAULT_CAPACITY,sizeof(Node\*));
    assert(ret->buckets!=NULL);
    return ret;
}

void insert(HashMap\* map,Node\* node){
    assert(map!=NULL&&node!=NULL);
    size\_t index = getIndex(node->key,map->capacity);
    if(map->buckets[index]==NULL){
        node->next = NULL;
        map->buckets[index] = node;
    }else{
        node->next = map->buckets[index];
        map->buckets[index] = node;
    }
}

void put(HashMap\* map,key\_t key,val\_t val){
    assert(map != NULL);
    //判断是否需要扩容
    if(map->size >= map->capacity\*factor) resize(map);
    putVal(key,val,map->buckets,&map->size,map->capacity);
}
static inline size\_t getHashcode(key\_t key){
    return key ^ (key>>16);//这是32位数的扰动函数
}
static inline size\_t getIndex(key\_t key,size\_t bucket_size){//由于bucketsize一定是2的次方，所以size-1和key相与得到的就是下标
    return getHashcode(key)&(bucket_size-1);
}
static void putVal(key\_t key,val\_t val,Node\*\* buckets,size\_t\* returnSize,size\_t bucketSize){
    //获取位置
    size\_t index = getIndex(key,bucketSize);
    Node \* node = buckets[index];
    if(node==NULL){//插入位置为空
        node = (Node\*)malloc(sizeof(Node));
        assert(node!=NULL);
        node->val = val;
        node->key = key;
        node->next = NULL;
        buckets[index] = node;
        (\*returnSize)++;    //哈希表内的元素增加
        return;
    }
    //插入位置不为空，说明发生冲突，使用链地址法，遍历链表
    while (node!=NULL){
        //如果key相同就覆盖
        if(node->key==key){
            node->val = val;
            return;
        }
        node = node->next;
    }
    //当前的key不在链表中，则插入链表头部
    Node\* newNode = (Node\*)malloc(sizeof(Node));
    assert(newNode != NULL);
    newNode->next = buckets[index];
    buckets[index] = newNode;
    (\*returnSize)++; //哈希表内元素增加
}


static void resize(HashMap\* map){
    map->capacity <<= 1;            //扩大两倍容量，相当于左移一位
    Node \*\* tmp = map->buckets;     //存下之前的内存地址
    map->buckets = (Node\*\*)calloc(map->capacity,sizeof(Node\*)); //重新分配
    assert(map->buckets!=NULL);
    rehash(map,tmp);//重新哈希处理
    free(tmp);                                          //释放之前的内存
}


static void rehash(HashMap\* map,Node\*\* preTable){//采取java1.7的方式进行rehash也就是最简单直接的直接重新哈希插入
    size\_t preCap = map->capacity / 2; //改变前的有效区域
    for(size\_t i=0;i<preCap;i++){
        if(preTable[i] != NULL){//判断对应的key是否需要重新换位置,如果对最新掩码多出来的1敏感则需要rehash
            Node \*preNode;
            Node \*curNode = preTable[i];
            while (curNode!=NULL){
                preNode = curNode;
                curNode = curNode->next;
                insert(map,preNode);
            }
        }
    }
}


val\_t\* get(HashMap\* map,key\_t key){//前面的写好后，那么get就很好写了
    int index = getIndex(key,map->capacity);
    Node \* node = map->buckets[index];
    while (node != NULL){
        if(node->key==key){
            return &(node->val);
        }
        node = node->next;
    }
    return NULL;//没找到返回NULL指针
}
static void del\_nodes(Node\* head){//删除单条链表
    Node\* pre;
    Node\* cur = head;
    while (cur != NULL){
        pre = cur;
        cur = cur->next;
        free(pre);
    }
}
void destroy(HashMap\* map){//销毁整个哈希表
    size\_t sz = map->capacity;
    Node \*\* tmp = map->buckets;
    for(size\_t i = 0;i<sz;i++){
        if(tmp[i]!=NULL)
            del\_nodes(tmp[i]);
    }
    free(tmp);
    free(map);
}
#endif //MY\_TINY\_STL\_HASHMAP\_C\_H




/\*题目测试接口\*/ 
int\* twoSum(int\* nums, int numsSize, int target, int\* returnSize) {//两数之和万恶之源
    HashMap\* map = init();
    for(int i=0;i<numsSize;i++){
        int\* t = get(map,target-nums[i]);
        if(t != NULL){
            int \*ret = (int\*)malloc(sizeof(int)\*2);
            \*returnSize = 2;
            ret[0] = \*t;
            ret[1] = i;
            return ret;
        }
        put(map,nums[i],i);
    }
    \*returnSize = 0;
    destroy(map);
    return NULL;
}

总结

通过这次手撕比较规范的哈希表的收获：

  1. 更加深入的理解了哈希表的基本实现思想。
  2. 从LeetCode刷题无用的感觉到有用，比如时刻需要的链表增删操作。
  3. 有点遗憾，没能按照java1.8的思路再进一步优化哈希表。

看了很多大厂的面试题，现在对哈希表这块数据结构的考量是越来越严苛了，比如你如果走的 java 后端岗位，面试可能需要你回答 java HashMap 源码的相关实现部分，深挖原理，而不是死记硬背了，所以最好的学习方式就是学习源码，然后根据学到的思想自己实现一些功能。

参考：
[1]. 《数据结构与算法》

[2]. HashMap跟面试官扯了半个小时

2401_87256382
关注
C/C++手撕哈希表详解
CppYyds的博客
11-26 7403
文章目录关于实现源码哈希表的理论知识哈希表的定义桶数组散列函数散列函数的构造扰动函数 和 按位与哈希冲突HashMap实现类型定义（键值对以及对应节点）哈希表的数据初始化方法（构造方法）根据散列函数得到位置put方法扩容方法get方法完整代码测试：LeetCode 1.两数之和总结 关于实现源码 实现源码仓库在线查看链接： C语言实现 C++实现 哈希表的理论知识 哈希表的定义 哈希表也叫散列表，我们先来看看哈希表的定义： 哈希表是保存键值映射关系的查找表，通过关键字可以很快找到对应的值。 简单说来说，
手撕哈希表（HashTable）——C++高阶数据结构详解
qq_61500888的博客
10-02 9041
带你一命通关哈希表（散列表） 十分钟手撕数据结构原理
轻松手撕 HashMap
CoderZk的博客
12-15 949
文章目录手撕 HashMapTreeMap分析哈希表 (Hash Table)哈希冲突 手撕 HashMap TreeMap分析 时间复杂度: 添加, 删除, 搜索: O(logn) 特点: Key 必须具备可比较性 元素的分布是有顺序的 在实际应用中, 很多时候的需求 Map 中存储的元素不需要讲究顺序 Map 中的 Key 不需要具备可比较性 不考虑顺序, 不考虑 Key 的可比较性, Map 有更好的实现方案, 平均时间复杂度可以达到 O(1) 那就是采取哈希表来实现 M
哈希表操作（c语言版）
11-24
////采用除留余数法定义哈希表，哈希表长度为10，哈希函数为H(key)=key%13。产生冲突时采用线性探测法实现下面要求的功能。 ////（1）初始化哈希表,置空哈希表 ////（2）在哈希表中查找元素 ////（3）在哈希表中插入元素 ////（4）输出哈希表中所有元素 ////（5）建立Hash表
手撕 HashMap（空口无凭，实战为真）
小龙JWY的博客
03-05 805
如果你还不是很理解HashMap，建议你先看我上一篇博客，深入理解HashMap。 写HashMap的流程，写Map接口表明要实现哪些方法，实现AbstractMap抽象类实现一些基本方法(如 toString()，isEmpty() 等等)，然后写HashMap类，从内部需要哪些成员开始，定义内部类Node，然后完成构造方法，之后写入最重要的 put()，get()，remove()三个最重要...
【C++图解专栏】手撕数据结构与算法，探寻算法的魅力
Newin2020的博客
08-20 9704
在这个专栏，我将带着大家一起用 C++ 手撕基础的数据结构与算法，希望能够带领大家快速入门这个课程。数据结构与算法是大学计算机专业课中最重要的一门，学起来必然不轻松，所以遇到困难是非常正常的一件事。相信我，只要能够坚持下去，自己动手敲一遍一定会有不少的收获！
手撕HashMap（原理）
一包大豫竹的博客
07-14 1362
package com.david; public interface Map&amp;amp;lt;K,V&amp;amp;gt; { //向HashMap中插入值 public V put(K k,V c); //根据Key获取HashMap中的值 public V get(K k); //获取集合中的元素个数 public int size(); //获取几何...
清除哈希表中的所有元素
刘利新西安
05-09 1427
/* Remove all values from Java HashMap example This Java Example shows how to remove all values from HashMap object or empty HashMap or clear HashMap using clear method. */ import java.util.Ha
哈希一刀流——布隆过滤器详解
qq_61500888的博客
10-21 3041
带你一命通关 C++ 布隆过滤器 十分钟手撕哈希内涵
全网最系统最全面的c/c++ Linux服务端开发高级架构师全能体系总结，他来了
m0_58687318的博客
08-19 3013
涵盖了linux C++服务端开发架构师每个阶段所需要学习的知识点。
哈希表的查找、删除等相关算法
11-09
哈希表中线性探查法解决冲突，查找，删除、插入关键字等操作
C++自学路线
vernon055的博客
06-29 2999
一、C++基础（3个月） 1、面向对象的三大特性：封装、继承、多态 封装可以隐藏实现细节，使得代码模块化；继承可以扩展已存在的代码模块（类）；它们的目的都是：代码重用。而多态则是为了实现另一个目的——接口重用。 2、类的访问权限：private、protected、public 3、类的构造函数、析构函数、赋值函数、拷贝函数 4、移动构造函数与拷贝构造函数对比 C++11新出的，可以不用管。 5、深拷贝与浅拷贝的区别  ...
C++之手撕LRU算法结构
qq_43247276的博客
06-26 574
问题描述如下 设计一个数据结构，实现LRU Cache的功能(Least Recently Used – 最近最少使用缓存)。它支持如下2个操作： get 和 put。 int get(int key) – 如果key已存在，则返回key对应的值value（始终大于0）；如果key不存在，则返回-1。 void put(int key, int value) – 如果key不存在，将value插入；如果key已存在，则使用value替换原先已经存在的值。如果容量达到了限制，LRU Cache需要在插入新元素
哈希表(C语言实现)
最新发布
2303_82176667的博客
09-21 888
首先，我们将key 和value 封装成一个类Pair ，以表示键值对。//键值对int key;int *val;}Pair;其次，我们来定义哈希表的结构体// 基于数组实现哈希表//键值对int key;int *val;} Pair;//链表节点Pair* pair;}Node;//哈希表节点定义int size;//键值对的数量//哈希表的容量//触发扩容的负载因子阈值//扩容倍数//桶数组。
C语言 - 哈希表
weixin_67661394的博客
06-25 144
【代码】C语言 - 哈希表。
C语言哈希表用法
我的blog屋
09-27 1874
转自：https://blog.csdn.net/nameofcsdn/article/details/107297361 哈希表在头文件"uthash.h"中已经有了，只需要简单学习一下用法即可。 1，哈希结构体 #include "uthash.h" typedef struct { int key; int value; UT_hash_handle hh; } Hash; Hash *hash = NULL; 其中UT_hash_handle是头文件"uthash
C语言之哈希表
p=f/s
08-11 9514
写在前面：项目中用一张哈希表来存储设备的属性等信息，用到了哈希表这块，因为对哈希表用的并不是太多，认识没有那么深刻，所以，这里花时间对哈希总结以及写代码调试了一下，加深点印象。 正文： 1、哈希表的作用：为了根据数据部分的关键内容，计算出对应节点完整数据的内存地址。如果用链表的话，链表如果长度很长，就会需要花费较多的时间来遍历链表。为了解决效率问题，哈希表应运而生。 2、哈希表的排布状况，画...
散列表删除一个元素c语言,分享一个简单高效的哈希表C语言实现
weixin_39907133的博客
05-23 848
hashtable是一种非常实用的数据结构，尤其数据量相当大的时候，当然其中很关键的一点是hash算法。之前看redis数据库源码它里面实现hash的算法为murmurhash3，后来发现了这个xxhash。它的hash速度要比前者更快，而且散列效果也同样相当出色，当然此算法也有不足之处：64位hash只在64位程序跑很快，而且代码相比前者代码多，所以我基于此hash算法尝试写了一个hashtab...
【C语言链地址法】散列表/哈希表的创建、插入、查找、删除
Read by heart
08-13 5952
1.链地址法 #include <stdio.h> #include <stdlib.h> #include <math.h> #define maxSize 100 typedef struct ListNode { int element; struct ListNode* next; }ListNode; typedef ListNode* Li...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值