hash table相关--引入哈希桶的概念来实现一个哈希表

最新推荐文章于 2024-09-23 12:26:24 发布
最新推荐文章于 2024-09-23 12:26:24 发布
阅读量2k 收藏 1
点赞数

前面的讲述了如何用链地址法实现一个哈希表，那么今天来分析一下另一种解决哈希冲突的做法，即为每个Hash值，建立一个Hash桶(Bucket)，桶的容量是固定的，也就是只能处理固定次数的冲突，如1048576个Hash桶，每个桶中有4个表项(Entry)，总计4M个表项。其实这两种的实现思路雷同，就是对Hash表中每个Hash值建立一个冲突表，即将冲突的几个记录以表的形式存储在其中。

大致的思路是这样的：

首先 哈希桶 的个数是固定的，有用户构建的时候输入，一旦构建，个数就已经固定；查找的时候首先将key值通过哈希函数获取哈希值，根据哈希值获取到对应的哈希桶，然后遍历哈希桶内的pairs数组获取。

struct Bucket {
    unsigned int count;
    Pair *pairs;
};


struct StrMap {
    unsigned int count;
    Bucket *buckets;
};



strmap.h


#ifndef _STRMAP_H_
#define _STRMAP_H_


#ifdef __cplusplus
extern "C"
{
#endif


#include <stdlib.h>
#include <string.h>


typedef struct StrMap StrMap;


/*
 * This callback function is called once per key-value when iterating over
 * all keys associated to values.
 *
 * Parameters:
 *
 * key: A pointer to a null-terminated C string. The string must not
 * be modified by the client.
 *
 * value: A pointer to a null-terminated C string. The string must
 * not be modified by the client.
 *
 * obj: A pointer to a client-specific object. This parameter may be
 * null.
 *
 * Return value: None.
 */
typedef void(*sm_enum_func)(const char *key, const char *value, const void *obj);


/*
 * Creates a string map.
 *
 * Parameters:
 *
 * capacity: The number of top-level slots this string map
 * should allocate. This parameter must be > 0.
 *
 * Return value: A pointer to a string map object, 
 * or null if a new string map could not be allocated.
 */
StrMap * sm_new(unsigned int capacity);


/*
 * Releases all memory held by a string map object.
 *
 * Parameters:
 *
 * map: A pointer to a string map. This parameter cannot be null.
 * If the supplied string map has been previously released, the
 * behaviour of this function is undefined.
 *
 * Return value: None.
 */
void sm_delete(StrMap *map);


/*
 * Returns the value associated with the supplied key.
 *
 * Parameters:
 *
 * map: A pointer to a string map. This parameter cannot be null.
 *
 * key: A pointer to a null-terminated C string. This parameter cannot
 * be null.
 *
 * out_buf: A pointer to an output buffer which will contain the value,
 * if it exists and fits into the buffer.
 *
 * n_out_buf: The size of the output buffer in bytes.
 *
 * Return value: If out_buf is set to null and n_out_buf is set to 0 the return
 * value will be the number of bytes required to store the value (if it exists)
 * and its null-terminator. For all other parameter configurations the return value
 * is 1 if an associated value was found and completely copied into the output buffer,
 * 0 otherwise.
 */
int sm_get(const StrMap *map, const char *key, char *out_buf, unsigned int n_out_buf);


/*
 * Queries the existence of a key.
 *
 * Parameters:
 *
 * map: A pointer to a string map. This parameter cannot be null.
 *
 * key: A pointer to a null-terminated C string. This parameter cannot
 * be null.
 *
 * Return value: 1 if the key exists, 0 otherwise.
 */
int sm_exists(const StrMap *map, const char *key);


/*
 * Associates a value with the supplied key. If the key is already
 * associated with a value, the previous value is replaced.
 *
 * Parameters:
 *
 * map: A pointer to a string map. This parameter cannot be null.
 *
 * key: A pointer to a null-terminated C string. This parameter
 * cannot be null. The string must have a string length > 0. The
 * string will be copied.
 *
 * value: A pointer to a null-terminated C string. This parameter
 * cannot be null. The string must have a string length > 0. The
 * string will be copied.
 *
 * Return value: 1 if the association succeeded, 0 otherwise.
 */
int sm_put(StrMap *map, const char *key, const char *value);


/*
 * Returns the number of associations between keys and values.
 *
 * Parameters:
 *
 * map: A pointer to a string map. This parameter cannot be null.
 *
 * Return value: The number of associations between keys and values.
 */
int sm_get_count(const StrMap *map);


/*
 * An enumerator over all associations between keys and values.
 *
 * Parameters:
 *
 * map: A pointer to a string map. This parameter cannot be null.
 *
 * enum_func: A pointer to a callback function that will be
 * called by this procedure once for every key associated
 * with a value. This parameter cannot be null.
 *
 * obj: A pointer to a client-specific object. This parameter will be
 * passed back to the client's callback function. This parameter can
 * be null.
 *
 * Return value: 1 if enumeration completed, 0 otherwise.
 */
int sm_enum(const StrMap *map, sm_enum_func enum_func, const void *obj);


#ifdef __cplusplus
}
#endif


#endif


struct Pair {
    char *key;
    char *value;
};


struct Bucket {
    unsigned int count;
    Pair *pairs;
};


struct StrMap {
    unsigned int count;
    Bucket *buckets;
};


strmap.c


#include "strmap.h"


typedef struct Pair Pair;


typedef struct Bucket Bucket;


struct Pair {
char *key;
char *value;
};


struct Bucket {
unsigned int count;
Pair *pairs;
};


struct StrMap {
unsigned int count;
Bucket *buckets;
};


static Pair * get_pair(Bucket *bucket, const char *key);
static unsigned long hash(const char *str);


StrMap * sm_new(unsigned int capacity)
{
StrMap *map;

map = malloc(sizeof(StrMap));
if (map == NULL) {
return NULL;
}
map->count = capacity;
map->buckets = malloc(map->count * sizeof(Bucket));
if (map->buckets == NULL) {
free(map);
return NULL;
}
memset(map->buckets, 0, map->count * sizeof(Bucket));
return map;
}


void sm_delete(StrMap *map)
{
unsigned int i, j, n, m;
Bucket *bucket;
Pair *pair;


if (map == NULL) {
return;
}
n = map->count;
bucket = map->buckets;
i = 0;
while (i < n) {
m = bucket->count;
pair = bucket->pairs;
j = 0;
while(j < m) {
free(pair->key);
free(pair->value);
pair++;
j++;
}
free(bucket->pairs);
bucket++;
i++;
}
free(map->buckets);
free(map);
}


int sm_get(const StrMap *map, const char *key, char *out_buf, unsigned int n_out_buf)
{
unsigned int index;
Bucket *bucket;
Pair *pair;


if (map == NULL) {
return 0;
}
if (key == NULL) {
return 0;
}
index = hash(key) % map->count;
bucket = &(map->buckets[index]);
pair = get_pair(bucket, key);
if (pair == NULL) {
return 0;
}
if (out_buf == NULL && n_out_buf == 0) {
return strlen(pair->value) + 1;
}
if (out_buf == NULL) {
return 0;
}
if (strlen(pair->value) >= n_out_buf) {
return 0;
}
strcpy(out_buf, pair->value);
return 1;
}


int sm_exists(const StrMap *map, const char *key)
{
unsigned int index;
Bucket *bucket;
Pair *pair;


if (map == NULL) {
return 0;
}
if (key == NULL) {
return 0;
}
index = hash(key) % map->count;
bucket = &(map->buckets[index]);
pair = get_pair(bucket, key);
if (pair == NULL) {
return 0;
}
return 1;
}


int sm_put(StrMap *map, const char *key, const char *value)
{
unsigned int key_len, value_len, index;
Bucket *bucket;
Pair *tmp_pairs, *pair;
char *tmp_value;
char *new_key, *new_value;


if (map == NULL) {
return 0;
}
if (key == NULL || value == NULL) {
return 0;
}
key_len = strlen(key);
value_len = strlen(value);
/* Get a pointer to the bucket the key string hashes to */
index = hash(key) % map->count;
bucket = &(map->buckets[index]);
/* Check if we can handle insertion by simply replacing
* an existing value in a key-value pair in the bucket.
*/
if ((pair = get_pair(bucket, key)) != NULL) {
/* The bucket contains a pair that matches the provided key,
* change the value for that pair to the new value.
*/
if (strlen(pair->value) < value_len) {
/* If the new value is larger than the old value, re-allocate
* space for the new larger value.
*/
tmp_value = realloc(pair->value, (value_len + 1) * sizeof(char));
if (tmp_value == NULL) {
return 0;
}
pair->value = tmp_value;
}
/* Copy the new value into the pair that matches the key */
strcpy(pair->value, value);
return 1;
}
/* Allocate space for a new key and value */
new_key = malloc((key_len + 1) * sizeof(char));
if (new_key == NULL) {
return 0;
}
new_value = malloc((value_len + 1) * sizeof(char));
if (new_value == NULL) {
free(new_key);
return 0;
}
/* Create a key-value pair */
if (bucket->count == 0) {
/* The bucket is empty, lazily allocate space for a single
* key-value pair.
*/
bucket->pairs = malloc(sizeof(Pair));
if (bucket->pairs == NULL) {
free(new_key);
free(new_value);
return 0;
}
bucket->count = 1;
}
else {
/* The bucket wasn't empty but no pair existed that matches the provided
* key, so create a new key-value pair.
*/
tmp_pairs = realloc(bucket->pairs, (bucket->count + 1) * sizeof(Pair));
if (tmp_pairs == NULL) {
free(new_key);
free(new_value);
return 0;
}
bucket->pairs = tmp_pairs;
bucket->count++;
}
/* Get the last pair in the chain for the bucket */
pair = &(bucket->pairs[bucket->count - 1]);
pair->key = new_key;
pair->value = new_value;
/* Copy the key and its value into the key-value pair */
strcpy(pair->key, key);
strcpy(pair->value, value);
return 1;
}


int sm_get_count(const StrMap *map)
{
unsigned int i, j, n, m;
unsigned int count;
Bucket *bucket;
Pair *pair;


if (map == NULL) {
return 0;
}
bucket = map->buckets;
n = map->count;
i = 0;
count = 0;
while (i < n) {
pair = bucket->pairs;
m = bucket->count;
j = 0;
while (j < m) {
count++;
pair++;
j++;
}
bucket++;
i++;
}
return count;
}


int sm_enum(const StrMap *map, sm_enum_func enum_func, const void *obj)
{
unsigned int i, j, n, m;
Bucket *bucket;
Pair *pair;


if (map == NULL) {
return 0;
}
if (enum_func == NULL) {
return 0;
}
bucket = map->buckets;
n = map->count;
i = 0;
while (i < n) {
pair = bucket->pairs;
m = bucket->count;
j = 0;
while (j < m) {
enum_func(pair->key, pair->value, obj);
pair++;
j++;
}
bucket++;
i++;
}
return 1;
}


/*
 * Returns a pair from the bucket that matches the provided key,
 * or null if no such pair exist.
 */
static Pair * get_pair(Bucket *bucket, const char *key)
{
unsigned int i, n;
Pair *pair;


n = bucket->count;
if (n == 0) {
return NULL;
}
pair = bucket->pairs;
i = 0;
while (i < n) {
if (pair->key != NULL && pair->value != NULL) {
if (strcmp(pair->key, key) == 0) {
return pair;
}
}
pair++;
i++;
}
return NULL;
}


/*
 * Returns a hash code for the provided string.
 */
static unsigned long hash(const char *str)
{
unsigned long hash = 5381;
int c;


while (c = *str++) {
hash = ((hash << 5) + hash) + c;
}
return hash;
}


前一节与这节这两种实现方法看似比较类似，但也有差异：

基于哈希桶的情况下，由于Hash桶容量的限制，所以，有可能发生Hash表填不满的情况，也就是，虽然Hash表里面还有空位，但是新建的表项由于冲突过多，而不能装入Hash表中。不过，这样的实现也有其好处，就是查表的最大开销是可以确定的，因为最多处理的冲突数是确定的，所以算法的时间复杂度为O(1)+O(m)，其中m为Hash桶容量。

而另一种通过链表的实现，由于Hash桶的容量是无限的，因此，只要没有超出Hash表的最大容量，就能够容纳新建的表项。但是，一旦发生了Hash冲突严重的情况，就会造成Hash桶的链表过长，大大降低查找效率。在最坏的情况下，时间复杂度退化为O(n)，其中n为Hash表的总容量。当然，这种情况的概率小之又小，几乎是可以忽略的。

 转自
http://www.nowamagic.net/academy/detail/3008108




struct Pair {
    char *key;
    char *value;
};


struct Bucket {
    unsigned int count;
    Pair *pairs;
};


struct StrMap {
    unsigned int count;
    Bucket *buckets;
};
hanfazy
关注
HashTable哈希表/散列表（哈希桶）
simplehap的博客
05-02 1417
哈希桶的结构处理哈希冲突的开链法/拉链法 —-哈希桶 使用素数做哈希表的长度，可以降低哈希冲突 哈希桶的插入、删除、查找
深入哈希表（三）--拉链法（哈希桶）实现哈希表
ArchyLi
11-11 3327
一、简介为了解决线性探构造哈希表所出现的大量哈希冲突，我们采用了另外一种方法，便是开链法。而在SGI版本的STL中调用的也正是哈希桶的实现方法。注意：开链法实现哈希表的时候会出现很多很多的错误，比如各种模板错误，此时需要耐心，慢慢调整。同时又为了扩展hash_map与hash_set更改了一些模板参数，所以经过调试错误的过程，绝对会对模板有一个全新的认识。二、拉链法实现原理：采用了由N个头指针构成的
(9)引入哈希桶的概念来实现一个哈希表
wangpengqi的专栏
08-02 4184
前面的讲述了如何用链地址法实现一个哈希表，那么今天来分析一下另一种解决哈希冲突的做法，即为每个Hash值，建立一个Hash桶(Bucket)，桶的容量是固定的，也就是只能处理固定次数的冲突，如1048576个Hash桶，每个桶中有4个表项(Entry)，总计4M个表项。其实这两种的实现思路雷同，就是对Hash表中每个Hash值建立一个冲突表，即将冲突的几个记录以表的形式存储在其中。 大致的思
【C++】哈希桶
最新发布
Cayyyy的博客
09-23 2739
哈希桶是哈希表中用于存储数据的基本单元，也称为哈希槽或存储桶。
【数据结构】哈希桶
Cheng_913的博客
04-04 5650
　　在上一篇博客中，我们简单地介绍了哈希表，以及解决哈希冲突的办法；今天我们介绍解决哈希冲突的另一种方法——开散列法。开散列法又叫链地址法，首先对关键码集合用散列函数计算散列地址，具有相同地址的关键码归于同一子集合，每一个子集合称为一个桶，各个桶中的元素通过一个单链表链接起来，各链表的头结点组成一个向量。说起来可能很复杂，其实很简单，看一个图就明白了：假设哈希函数为Hash(key)=key%10...
Hash桶实现hash表
lj19890902的专栏
01-17 927
链接地址： http://blog.csdn.net/wangpengqi/article/details/9716315
哈希表，哈希桶的实现
weixin_53831496的博客
07-09 1084
顺序结构以及平衡树中，元素关键码与其存储位置之间没有对应的关系，因此在查找一个元素时，必须要经过关键码的多次比较。顺序查找时间复杂度为O(N)，平衡树中为树的高度，即O( )，搜索的效率取决于搜索过程中元素的比较次数。 理想的搜索方法：可以不经过任何比较，一次直接从表中得到要搜索的元素。 如果构造一种存储结构，通过某种函数(hashFunc)使元素的存储位置与它的关键码之间能够建立一一映射的关系，那么在查找时通过该函数可以很快找到该元素。、 向该结构当中： 插入元素： 根据待插入元素的关键码，用此函数计算出
JAVA-hash-table.zip_Table_hash_hash table java_java hash 查找_哈希表设
09-20
（1） 建立一个哈希表，哈希函数为除留余数法，处理冲突的方法为线性探测再散列或二次探测再散列。 （2） 往哈希表中依次存入插入多个单词。 （3） 显示哈希表的存储情况。 （4） 计算哈希表的平均查找长度。 （5） ...
哈希表-使用Go实现的用于IB-Trust的分布式哈希表.zip
03-04
在给定的压缩包文件中，“哈希表_使用Go实现的用于IB-Trust的分布式哈希表”可能是实现上述概念的一个具体项目。这个项目可能包含了DHT的实现代码，包括节点管理、路由算法、数据存储和一致性策略等部分。通过对该...
hash-table-benchmark:哈希表的基准
06-26
哈希表基准 使用字符串键和 Google farmhash 作为哈希函数的哈希表基准 Google 计算引擎，n1-highmem-2（2 个 vCPU，13 GB 内存），x86_64 Intel(R) Xeon(R) CPU @ 2.60GHz GenuineIntel GNU/Linux 给定不同大小的...
哈希表-使用Go实现的一个分片的哈希表.zip
03-04
分片哈希表（Sharded Hash Table）是哈希表的一种变体，它的主要思想是将单个大哈希表拆分为多个小的哈希表，每个小哈希表称为一个“分片”。这种方法可以提高并发性能，因为不同的分片可以在不同的处理器核心上并行...
八数码问题使用HashTable优化查找后的版本
hazqfp的专栏
02-27 780
在《双向广度优先搜索算法框架及八数码问题例程》一文中，给出了使用双向广度优先搜索算法解决八数码问题的一个 简单版本，查找都是线性的，没有优化。这里给出使用HashTable优化后的版本！ /*  * Author: puresky  * Date: 2010.01.12  * Purpose: solve EIGTH NUMBER problem!  */ #includ
hash 和 hash桶
哈尼的博客
08-31 6266
hash 桶 哈希桶就是为了解决哈希冲突 哈希桶算法其实就是链地址解决冲突的方 https://www.cnblogs.com/xqn2017/p/7997666.html https://blog.csdn.net/tanggao1314/article/details/51457585 ...
hash：哈希表 哈希桶
xiao_xiao21的博客
11-25 963
hash（1）:线性探测 哈希表
哈希和哈希桶
TONGtongTONG000的博客
11-02 2082
概念 数据结构中有一类常用于搜索，给定一个元素集合，常见的可用于搜索的算法有 遍历，遍历是十分粗暴简单的手段，对于元素的集合没有特殊要求，时间复杂度是O(N)。效率通常较低。 二分查找，二分查找要求元素集合有序，时间复杂度为O(logN), 二叉搜索树，查找规则简单，但是退化为单支树时间复杂度是O(N), AVL树和红黑树，时间复杂度都是O(logN). 上面的这些常用的方法无一例外都有一个关键步骤就是元素的比较，通过比较待查找元素和集合中的元素，来确定该元素在集合中的位置。真实的效率取决于比较的次数。 如
【哈希】怎么用哈希表优化查找子数组问题-力扣930，560【超详细的算法教程】
后端开发为主+人工智能
05-22 782
【哈希】使用哈希算法优化查找子数组问题 力扣930 力扣560 详细算法解释教程
Hash算法 Hash链 桶 Hash值
李豪 Linux C++
05-02 591
关于Hash算法
数据结构：hash桶结构
liuhuiyan_2014的专栏
08-09 4191
#include <iostream> #include <stdlib.h> #define _SIZE_ 7 using namespace std;template<typename Type> struct Node { Type data; Node *next; Node(Type d = Type()) :data(d), next(NULL){} };temp
哈希表、哈希桶的实现
2021dragon的博客
01-13 3638
文章目录哈希概念哈希冲突哈希函数哈希冲突解决闭散列开散列 哈希概念 顺序结构以及平衡树中，元素关键码与其存储位置之间没有对应的关系，因此在查找一个元素时，必须要经过关键码的多次比较。搜索的效率取决于搜索过程中元素的比较次数，因此顺序结构中查找的时间复杂度为O(N)O(N)O(N)，平衡树中查找的时间复杂度为树的高度O(logN)O(logN)O(logN)。 而最理想的搜索方法是，可以不经过任何比较，一次直接从表中得到要搜索的元素，即查找的时间复杂度为O(1)O(1)O(1)。 如果构造一种存储结构，该结构
数据结构课程设计----哈希表设计
12-24
下面是一个简单的哈希表设计的示例代码： ```python class HashTable: def __init__(self): self.size = 10 self.table = [[] for _ in range(self.size)] def _hash_function(self, key): return key % self...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值