哈希桶

哈希桶原理与实现
最新推荐文章于 2025-09-07 20:32:33 发布
最新推荐文章于 2025-09-07 20:32:33 发布
阅读量78 收藏
点赞数
CC 4.0 BY-SA版权
文章标签： 数据结构与算法
原文链接：http://www.cnblogs.com/liu-song/p/5398153.html
  先说说为什么使用哈希桶，记得以前在学校读书的时候那本软件工程书上的做法是一个将经过哈希算法的值保存在一个链表数组中，就像下面这样，当我们需要插入或者删除的时候，直接对链表操作就行。在Linux多线程的情况下，临界资源在使用前要先加锁，如果对整个链表数组加锁，那这个服务器就不要工作了。为了减小加锁的粒度，数组的长度尽量长，那样的话就能减小阻塞的几率。但是锁的使用（包括加锁、解锁等）也影响性能，所以锁又要尽量少，这个时候就得取一个折中值。把链表数组的每一链表拿出来单独管理，那么它就是一个哈希桶了。


#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
 
#define FAILED -1
#define SUCCESS 0
 
#define MRU_HASH_SEED 110
 
typedef unsigned long long int uint64_t;
 
typedef struct Node
{
uint64_t hash_key;
unsigned char path[32];
struct Node *next;
}Node;
 
typedef struct Bucket
{
unsigned int lock;
unsigned short bucket_id;
unsigned int entry_num;
struct Node *head;
//struct Node *tail;
}Bucket;
 
typedef struct HashMap
{
unsigned char BucketNum;
Bucket *BucketTable;
}HashMap;
 
uint64_t  MurmurHash(const void* key, int len)  
{  
unsigned int seed = MRU_HASH_SEED;
        const uint64_t m = 0xc6a4a7935bd1e995;  
        const int r = 47;  
  
        uint64_t h = seed ^ (len * m);  
  
        const uint64_t * data = (const uint64_t *)key;  
        const uint64_t * end = data + (len/8);  
 
        while(data != end)  
        {  
                uint64_t k = *data++;  
  
                k *= m;   
                k ^= k >> r;   
                k *= m;   
  
                h ^= k;  
                h *= m;   
        }  
  
        const unsigned char *data2 = (const unsigned char*)data;  
  
        switch(len & 7)  
        {  
        case 7: h ^= (uint64_t)(data2[6]) << 48;  
        case 6: h ^= (uint64_t)(data2[5]) << 40;  
        case 5: h ^= (uint64_t)(data2[4]) << 32;  
        case 4: h ^= (uint64_t)(data2[3]) << 24;  
        case 3: h ^= (uint64_t)(data2[2]) << 16;  
        case 2: h ^= (uint64_t)(data2[1]) << 8;  
        case 1: h ^= (uint64_t)(data2[0]);  
                h *= m;  
        };  
   
        h ^= h >> r;  
        h *= m;  
        h ^= h >> r;  
  
        return h;  
}
 
void FreeList(Bucket* bucket)
{
struct Node *temp;
struct Node *head;
unsigned int count = 0;
 
if(NULL == bucket)
{
printf("the bucket is NULL\n");
return ;
}
 
head = bucket->head;
while(NULL != head)
{
temp = head;
head = head->next;
free(temp);
++count;
}
 
if(0 != count)
{
printf("free node number is: %u\n", count);
}
}
 
int HashMapInit(HashMap* hashMap)
{
unsigned short bucketNum = 0;
unsigned short idx = 0;
Bucket *pBucket = NULL;
 
printf("input the bucketNum\n");
scanf("%d", &bucketNum);
 
if(0 == bucketNum)
{
printf("the bucketNum is 0\n");
return 0;
}
 
hashMap->BucketTable = (Bucket*)malloc(bucketNum*sizeof(Bucket));
if(NULL == hashMap->BucketTable)
{
printf("alloc bucket failed\n");
return FAILED;
}
hashMap->BucketNum = bucketNum;
 
for(idx=0; idx<bucketNum; ++idx)
{
pBucket = &(hashMap->BucketTable[idx]);
pBucket->bucket_id = idx;
//获取锁
pBucket->lock = 0;
pBucket->entry_num = 0;
pBucket->head = NULL;
//pBucket->tail = NULL;
}
 
return SUCCESS;
}
 
int GetBucketIdx(HashMap* hashMap, uint64_t hash_key)
{
unsigned short idx = 0;
 
if(NULL == hashMap)
{
return FAILED;
}
 
idx = hash_key%(hashMap->BucketNum);
return idx;
}
 
int BucketInsert(Bucket* bucket, struct Node* node)
{
//先加锁
if(NULL == bucket)
{
printf("the bucket is NULL\n");
return FAILED;
}
 
if(NULL == node)
{
printf("the node is NULL\n");
return FAILED;
}
 
node->next = bucket->head;
bucket->head = node;
/*
if(NULL == bucket->tail)
{
bucket->tail = node;
}
*/
bucket->entry_num++;
 
return SUCCESS;
}
 
int HashMapInsert(HashMap* hashMap, unsigned char* path)
{
uint64_t hash_key = 0;
unsigned short bucket_idx = 0;
Bucket* pBucket = NULL;
 
if(NULL == hashMap)
{
printf("the hash map is NULL\n");
return FAILED;
}
 
if(NULL == path)
{
printf("the file path is NULL\n");
return FAILED;
}
 
hash_key = MurmurHash(path, strlen(path));
printf("file [%s],Mrumru hash key is: [%llu]\n", path, hash_key);
 
bucket_idx = (unsigned short)GetBucketIdx(hashMap, hash_key);
printf("hash key [%llu] belong to the bucket: %d\n", hash_key, bucket_idx);
 
pBucket = &(hashMap->BucketTable[bucket_idx]);
struct Node* node = (struct Node*)malloc(sizeof(struct Node));
if(NULL == node)
{
printf("alloc node failed\n");
return FAILED;
}
node->hash_key = hash_key;
strcpy(node->path, path);
 
int ret = BucketInsert(pBucket, node);
if(FAILED == ret)
{
printf("bucket inset node failed\n");
free(node);
return FAILED;
}
 
return SUCCESS;
}
 
int BucketDel(Bucket* bucket, uint64_t hash_key)
{
if(NULL == bucket)
{
printf("the bucket is NULL\n");
return FAILED;
}
 
if(0 == bucket->entry_num)
{
return FAILED;
}
 
struct Node* temp = bucket->head;
if(temp->hash_key == hash_key)
{
bucket->head = temp->next;
free(temp);
return SUCCESS;
}
 
struct Node* next = temp;
while(NULL != temp)
{
next = temp;
next = next->next;
if(next->hash_key == hash_key)
{
temp->next = next->next;
free(next);
return SUCCESS;
}
temp = next;
}
 
return FAILED;
}
 
int HashMapDel(HashMap* hashMap, unsigned char* path)
{
uint64_t hash_key = 0;
unsigned short bucket_idx = 0;
Bucket* pBucket = NULL;
 
if(NULL == hashMap)
{
printf("the hash map is NULL\n");
return FAILED;
}
 
if(NULL == path)
{
printf("the file path is NULL\n");
return FAILED;
}
 
hash_key = MurmurHash(path, strlen(path));
printf("file [%s],Mrumru hash key is: [%llu]\n", path, hash_key);
 
bucket_idx = (unsigned short)GetBucketIdx(hashMap, hash_key);
printf("hash key [%llu] belong to the bucket: %d\n", hash_key, bucket_idx);
 
pBucket = &(hashMap->BucketTable[bucket_idx]);
int ret = BucketDel(pBucket, hash_key);
if(SUCCESS == ret)
{
printf("del node failed,file path:[%s]\n", path);
return FAILED;
}
 
printf("del node success,file path:[%s]\n", path);
return SUCCESS;
}
 
int HashMapRelease(HashMap* hashMap)
{
unsigned short idx = 0;
unsigned ItemNum = 0;
Bucket* bucket = NULL;
//加锁
if(NULL == hashMap)
{
printf("hash map is already NULL\n");
return SUCCESS;
}
 
ItemNum = hashMap->BucketNum;
for(idx=0; idx<ItemNum; ++idx)
{
bucket = &(hashMap->BucketTable[idx]);
FreeList(bucket);
}
 
free(hashMap);
hashMap = NULL;
 
return SUCCESS;
}
 
int main(int argc, char *argv[])
{
uint64_t hashKey = 0;
HashMap *hashMap = NULL;
unsigned int idx = 0;
 
char *p[] = {"/opt/mkmfs/mnt/0/d/1.ts",
"/opt/mkmfs/mnt/0/d/2/ts"
};
 
hashMap = (HashMap*)malloc(sizeof(HashMap));
if(NULL == hashMap)
{
printf("alloc hash map failed\n");
return 0;
}
printf("alloc hash map success\n");
if(SUCCESS == HashMapInit(hashMap))
{
printf("Init hash map success\n");
}
 
int ret = 0;
for(idx=0; idx<2; ++idx)
{
ret = HashMapInsert(hashMap, p[idx]);
if(SUCCESS == ret)
{
printf("hash map insert success\n");
}
}
 
ret = HashMapDel(hashMap, p[0]);
if(SUCCESS == ret)
{
printf("del node success\n");
}
if(SUCCESS == HashMapRelease(hashMap))
{
printf("release hash map success\n");
}
 
return 0;
}
 
 
    例子中的哈希算法是google的murmur哈希，它的效率比传统的哈希算法快很多，同时哈希冲突的几率很低。虽然哈希桶实现了，但是另外一个问题又出现了--查找效率。因此一般实现哈希桶的同时，除了在哈希桶中放一个链表，还会放一个红黑树。红黑树的查找效率极高，但是它会占用一部分额外的存储，如果在可接受的范围，那么这种组合的效率会很高。
    这个例子中未考虑哈希冲突的冲突，对于算法导致一些额外不足之处，算法一般会用另外的流程处理，但是这样仅仅只能说是对算法的完善，未考虑这些流程在性能上的影响。很多大型服务器首先在源端保证哈希冲突几率很小，其次如果发生哈希冲突，那么直接不把这个元素添加到整个哈希桶数组中，可能解决哈希冲突消耗的性能远高于不对哈希桶操作而直接对对象操作。

转载于:https://www.cnblogs.com/liu-song/p/5398153.html

hash桶的初步探讨
c123nANDY的博客
12-21 682
首先，利用hash桶是希望减少内存使用，使得程序更加的高效，今天谈谈hash桶的一步步演变。 1.假如有一堆数据，设为x[]，范围是00-000-0000 - 99-999-9999，如果我需要查询这堆数据中的某个值，如果利用数组的做法，将会变成，s8 x[99999999 + 1]，如此大的数组，这显然是不符合实际情况的做法。 2.假如还是一堆数据，设为x[]，范围依然是00-000-0000-...
哈希和哈希桶
TONGtongTONG000的博客
11-02 2204
概念 数据结构中有一类常用于搜索，给定一个元素集合，常见的可用于搜索的算法有 遍历，遍历是十分粗暴简单的手段，对于元素的集合没有特殊要求，时间复杂度是O(N)。效率通常较低。 二分查找，二分查找要求元素集合有序，时间复杂度为O(logN), 二叉搜索树，查找规则简单，但是退化为单支树时间复杂度是O(N), AVL树和红黑树，时间复杂度都是O(logN). 上面的这些常用的方法无一例外都有一个关键步骤就是元素的比较，通过比较待查找元素和集合中的元素，来确定该元素在集合中的位置。真实的效率取决于比较的次数。 如
Hash桶的概念
baidu_15113429的博客
08-18 1万+
在Java的Hashmap中就是使用hash桶进行构造的，hashmap中的key值不能相同，下面学习hash桶的原理。http://luoyafei.blog.51cto.com/10731357/1772077
哈希桶 entry_哈希表算法原理
weixin_39980082的博客
01-18 708
基本概念哈希表（Hash Table）是一种根据关键字直接访问内存存储位置的数据结构。通过哈希表，数据元素的存放位置和数据元素的关键字之间建立起某种对应关系，建立这种对应关系的函数称为哈希函数。哈希函数构造方法哈希表的构造方法是：假设要存储的数据元素个数为n，设置一个长度为m（m≥n）的连续存储单元，分别以每个数据元素的关键字 Ki(0<= i <=n-1) 为自变量，通过哈希函数 ...
哈希桶的实现
xy的博客
06-20 1万+
【开散列法】 开散列法又叫链地址法(开链法)。 开散列方法首先对关键码集合用某一个散列函数计算他们的存放位置。若设散列表地址空间的 所有位置是从0到m-1，则关键码集合中的所有关键码被划分为m个子集合，通过散列函数计算出来的 具有相同地址的关键码归于同一子集合。称同一子集合中的关键码互为同义词，每一个子集合称为 一个桶。通常各个桶中的表项通过一个单链表链接起来，亦称为同义词子表。
【C++】哈希桶
A.的博客
09-23 4082
哈希桶是哈希表中用于存储数据的基本单元，也称为哈希槽或存储桶。
哈希--哈希桶
popingcat的博客
03-25 682
上面的代码要注意的是它的扩容，它直接重新申请一个数组链表，而不是像开放地址法一样，进行一个重新搞一个对象，然后在对象的新表里面进行挪动数据了。现在哈希桶的这个扩容方法减少了insert的调用！哈希桶是哈希表（散列表）中的一个概念，是哈希表数组中的每个元素 ，用于存储键值对数据。
数据结构——哈希表、哈希桶
mastershooter的博客
06-03 1663
此时，我们可根据哈希表的大小，选择其中各种符号分布均匀的若干位作为哈希地址。顺序结构以及平衡树中，元素关键码与其存储位置之间没有对应的关系，因此在查找一个元素时，必须要经过关键码的多次比较，顺序查找时间复杂度为O(N),平衡树中为树的高度,即O(logN),搜索的效率取决于搜索过程种元素的比较次数。与闭散列的哈希表不同的是，在实现开散列的哈希表时，我们不用为哈希表中的每个位置设置一个状态字段，因为在开散列的哈希表中，我们将哈希地址相同的元素都放到了同一个哈希桶中，并不需要经过探测寻找所谓的“下一个位置”。
【数据结构】哈希表与哈希桶
℉f的博客
03-20 3407
本篇文章我们共同学习哈希结构，哈希结构追求更极致的搜索效率。之前学习的结构中搜索的效率取决于搜索过程中元素的比较次数，因此顺序结构中查找的时间复杂度为O(N)，平衡树中查找的时间复杂度为树的高度O(logN)。那我们能不能构建一种数据结构，让搜索效率达到O(1)呢。如果构造一种存储结构，该结构能够通过某种函数使元素的存储位置与它的关键码之间能够建立一一映射的关系，那么在查找时就能通过该函数很快找到该元素进而达到O(1)的查找效率。接下来就让我们共同学习哈希结构。
【C++】：哈希和哈希桶
Yikefore的博客
02-16 912
哈希表和哈希桶的介绍以及实现
哈希（二）哈希桶
奥利奥恨情歌的博客
05-15 2269
哈希（二）哈希桶 概念 哈希桶又被称作开链法，开散列法。相比于闭散列法哈希桶更为灵活直观，存数据时不会浪费空间，开散列法存数据时由于避免哈希冲突，总会有百分之三十的空间浪费，当存储空间很大时将会造成大量的浪费。同时开散列法造成哈希冲突时不便于查找数据。所以我们有了哈希结构中的哈希桶。 哈希桶与开散列法一样的是需要开一段数组用于映射，不过不一样的是哈希桶的数组存的是指针所以哈希桶是一段指针数组...
哈希桶 entry_Redis学习笔记哈希桶和底层数据结构
weixin_28958727的博客
01-27 698
关注爱因诗贤每天进步一点点导读前面文章介绍了 Redis基本数据类型和这些数据类型对应的一些操作，知道了 Redis很快的原因是 内存和 数据结构，这篇文章就围绕 数据结构来介绍一下 Redis 底层有哪些数据结构，为什么这些数据结构会提升访问速度，学习这些底层数据结构将会加深对 Redis设计原理的理解。1.Redis 基本数据类型String(字符串)Set(集合)Sorte...
哈希表+哈希桶简介及实现
热门推荐
保持一颗永远好奇、勇于探索的心
08-01 1万+
什么是哈希呢？ 就是记录的储存位置和他的关键字之间建立一个确定的对应关系f，这里我们就可以这种对应关系f称之为哈希（Hash）函数
AMD KFD 技术分析 3-1: alloc memory in hsakmt
deeplyMind
09-04 176
本文分析了ROCm HSAKMT库中的核心API hsaKmtAllocMemory 的实现原理。该API为上层应用提供统一的内存分配接口，支持多种内存类型（VRAM、系统内存等）。文章详细解析了其参数校验、标志冲突检查、分配类型选择（系统内存、VRAM或Scratch内存）以及与aperture管理器的交互过程。同时介绍了典型使用场景（如VRAM分配、SVM一致性内存等）和内存管理机制（包括对象追踪、释放流程）。该API通过底层aperture管理和红黑树实现高效的内存分配与安全控制，支持多GPU共享和进
二叉树的前中后序遍历(迭代法)
最新发布
mrjieke6的博客
09-07 866
本文系统介绍了二叉树前序、中序和后序遍历的迭代实现方法。前序遍历采用栈结构，按;根→右→左 ;顺序入栈；中序遍历先全部左子树入栈再访问节点；后序遍历则通过修改前序遍历顺序为"根→右→左 ;后反转结果。三种遍历时间复杂度均为O(n)，空间复杂度最坏O(n)。与递归实现相比，迭代方法避免了栈溢出风险，处理大型树更稳定。每种遍历方式都配有详细代码解析、执行示例和复杂度分析，并讨论了实际应用场景，为掌握树结构操作提供了系统指导。
【牛客刷题-剑指Offer】BM18 二维数组中的查找：一题四解，从暴力到最优
字节卷动
09-06 173
方法时间复杂度空间复杂度优点缺点适用场景暴力遍历On×mOn×mO1O(1)O1简单直接，易实现效率低，不适合大数据量小规模数据二分查找Omlog⁡nOmlognO1O(1)O1利用行有序，效率较高未利用列有序特性行数较少时Z字形查找OnmO(n + m)OnmO1O(1)O1最优解，利用行列有序无各种规模数据递归分治平均优于OnmO(nm)OnmOlog⁡nmOlognm。
机器学习：后篇
2301_82065950的博客
09-04 994
本文介绍了多种机器学习算法的原理与应用，主要包括KNN、朴素贝叶斯、决策树、随机森林、线性回归、逻辑回归和K-means聚类。KNN通过计算样本距离进行分类，但计算量大且易受维度灾难影响；朴素贝叶斯基于贝叶斯理论，通过独立性假设简化计算；决策树通过信息增益或基尼指数构建分类模型，但易过拟合；随机森林通过多决策树投票提升分类效果；线性回归采用最小二乘法或梯度下降优化参数；逻辑回归结合线性回归与Sigmoid函数实现分类；K-means通过簇内差异最小化进行无监督聚类。每种算法均配有scikit-learn的A
2025年数学建模国赛参考论文发布
qq_33690821的博客
09-05 1779
对于问题二，即通过BMI分组确定男胎最佳NIPT时点以最小化风险，我们使用K-means聚类算法和决策树算法对BMI进行分组（聚类数k依据碎石图确定），定义Y染色体浓度≥4%为“达标”，以90的孕妇能够达标的时间周作为最佳的NIPT点。最终我们得到了详细的BMI分组，并对风险进行了评估。本研究创新性地将AI姿态识别、运动生物力学和机器学习相结合，建立了从动作分析到成绩预测再到训练指导的完整技术链条，为智能体测和个性化运动训练提供了科学的理论基础和实用的技术方案，具有重要的应用价值和推广前景。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值