Hashdict

已于 2022-07-17 11:41:01 修改
阅读量332 收藏
点赞数 3
分类专栏： C++ 文章标签： C++
于 2021-09-29 19:08:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_54669536/article/details/119851474
版权

Hashdict


宏定义 


#define DICT_OK 1
#define DICT_ERR 0

#define dictHashKey(d, key) (d)->type->hashFunction(key)
#define dictSetKey(d, entry, _key_)
#define dictSetVal(d, entry, _val_)
#define dictIsRehashing(d) ((d)->rehashidx != -1)
#define DICT_HT_INITIAL_SIZE     4
#define dictCompareKeys(d, key1, key2) \
    (((d)->type->keyCompare) ? \
        (d)->type->keyCompare((d)->privdata, key1, key2) : \
        (key1) == (key2))
#define dictFreeVal(d, entry) \
    if ((d)->type->valDestructor) \
        (d)->type->valDestructor((d)->privdata, (entry)->v.val)
#define dictFreeKey(d, entry) \
    if ((d)->type->keyDestructor) \
        (d)->type->keyDestructor((d)->privdata, (entry)->key)
#define dictGetVal(he) ((he)->v.val)
static int dict_can_resize = 1;
static unsigned int dict_force_resize_ratio = 5;

//哈希表节点结构
typedef struct dictEntry
{
	void* key;
	union {
		void* val;
		uint64_t u64;
		int64_t s64;
	}v;
	struct dictEntry* next;
}dictEntry;

在这里插入图片描述

//哈希表结构
typedef struct dictht {
	dictEntry** table;
	unsigned long size;
	unsigned long sizemask;
	unsigned long used;
}dictht;

在这里插入图片描述

//字典结构
typedef struct dict {
	dictType* type;
	void* privdata;
	dictht ht[2];
	long rehashidx;
	unsigned long iterators;
}dict;
// dictType 用于操作字典类型函数
typedef struct dictType {
	uint64_t(*hashFunction)(const void* key);	// 计算哈希值的函数
	void* (*keyDup)(void* privdata, const void* key);	// 复制键的函数
	void* (*valDup)(void* privdata, const void* obj);	// 复制值的函数
	int (*keyCompare)(void* privdata, const void* key1, const void* key2);	// 比较键的函数
	void (*keyDestructor)(void* privdata, void* key);	// 销毁键的函数
	void (*valDestructor)(void* privdata, void* obj);	// 销毁值的函数
} dictType;

在这里插入图片描述
字典迭代器：dictlterator

//重置哈希表各属性
static void dictReset(dictht* ht)
{
	ht->table = NULL;
	ht->size = 0;
	ht->sizemask = 0;
	ht->used = 0;
}
//创建字典结构
dict* dictCreate(dictType* type, void* privDataPtr)
{
	dict* d = (dict*)malloc(sizeof(*d));
	dictInit(d, type, privDataPtr);
	return d;
}
//初始化字典结构
int dictInit(dict* d, dictType* type, void* privDataPtr)
{
	dictReset(&d->ht[0]);
	dictReset(&d->ht[1]);
	d->type = type;
	d->privdata = privDataPtr;//需要传给特定类型函数的可选参数
	d->rehashidx = -1;//记录rehash的进度
	d->iterators = 0;//Redis字典自己实现的迭代器，用于遍历，该变量用于记录迭代器的运行数量
	return 1;
}

1）Rehash(渐进式扩展函数)

//渐进式扩展函数
int dictRehash(dict* d, int n)
{
	if (!dictIsRehashing(d))return 0;

	while (n--&&d->ht[0].used!=0)
	{ // n代表需要迁移的索引结点数量
		dictEntry* de, * nextde;
		//确保rehashidx没有越界
		assert(d->ht[0].size > (unsigned)d->rehashidx);
		while (d->ht[0].table[d->rehashidx] == NULL)
		{
			d->rehashidx++;
		}
		// 指向第一个非空索引的链表表头节点
		de = d->ht[0].table[d->rehashidx];
		// 将链表中的所有节点迁移到新哈希表（重新计算位置，在新表上可能就不是在一条链上了）
		while (de)
		{
			unsigned int h;
			// 保存下个节点的指针
			nextde = de->next;
			//计算结点插入的位置索引
			h = dictHashKey(d, de->key) & d->ht[1].sizemask;
			de->next = d->ht[1].table[h];
			d->ht[0].used--;
			d->ht[1].used++;
			de = nextde;
		}
		// 将刚迁移完的哈希表索引的指针设为空
		d->ht[0].table[d->rehashidx] = NULL;
		d->rehashidx++; // 更新 rehash 索引
	}
	free(d->ht[0].table);
	d->ht[0] = d->ht[1];
	dictReset(&d->ht[1]);
	d->rehashidx = -1;
	return 0;
}
//单步Rehash
static void dictRehashStep(dict* d)
{
	//要求该字典上不存在安全迭代器
	if (d->iterators == 0) dictRehash(d, 1);
}

在这里插入图片描述

2)键值对插入函数

//将键插入到字典中
dictEntry* dictAddRaw(dict* d, void* key)
{
	long index; 
	dictEntry* entry;
	dictht* ht;
	if (dictIsRehashing(d)) dictRehashStep(d);
	if ((index = _dictKeyIndex(d, key, dictHashKey(d, key))) == -1)	
		// 获取当前key的hash值，如果已经存在直接返回NULL
		return NULL;
	ht = dictIsRehashing(d) ? &d->ht[1] : &d->ht[0];
	entry = (dictEntry *)malloc(sizeof(*entry));// 分配内存空间
	entry->next = ht->table[index];	// 插入到index头部
	ht->table[index] = entry;//此处不是指向，相当于直接赋值，让新插入的节点成为新的头部
	ht->used++;	// 已有节点数加一
	dictSetKey(d, entry, key);
	return entry;
}
//将给定值对添加到字典中
int dictAdd(dict* d, void* key, void* val) // 添加一个键值对进入到dict中
{
	// 尝试添加键到字典，并返回包含了这个键的新哈希节点 T = O(N)
	dictEntry* entry = dictAddRaw(d, key);
	// 键已存在，添加失败
	if (!entry) return DICT_ERR;

	// 键不存在，设置节点的值
	// T = O(1)
	dictSetVal(d, entry, val);

	// 添加成功
	return DICT_OK;
}

在这里插入图片描述
3）索引获取函数

//获取hash index;返回可以将Key插入到哈希表的索引位置
static int dictKeyIndex(dict* d, const void* key)
{
	unsigned int h, idx, table;
	dictEntry* he;//哈希节点
    //如果需要的话，扩展哈希表
	if (dictExpandIfNeeded(d) == DICT_ERR)
	{
		return -1;
	}
	//获取哈希值
	h = dictHashKey(d, key);

	for (table = 0; table <= 1; table++)
	{  
		idx = h & d->ht[table].sizemask; //获取索引值
		he = d->ht[table].table[idx];// 获得哈希表索引上的结点（存在哈希冲突的话，改结点就是链表结点）

		while (he)
		{
			if (dictCompareKeys(d, key, he->key))//比较当前节点的值与给定值是否相等
				return -1;
			he = he->next;//继续找下一个节点
		}
		//程序执行到此处，说明0号哈希表中不存在该节点
		//此时若正在进行Rehash,则在1号哈希表中继续找，否则直接退出循环
		if (!dictIsRehashing(d))
			break;
	}
	return idx;//程序执行到此处，说明在哈希表中不存在该节点，可以放心插入，直接返回新获得的索引值
}

在这里插入图片描述
4）字典哈希表扩展系列函数(非渐进式)

//计算第一个大于等于 size 的 2 的 N 次方，用作新哈希表大小的值
//根据ht[0]的大小，确定rehash操作需要的ht[1]的大小
static unsigned long dictNextPower(unsigned long size)
{
	unsigned long i = DICT_HT_INITIAL_SIZE;

	if (size >= LONG_MAX) return LONG_MAX;
	while (1) {
		if (i >= size)
			return i;
		i *= 2;
	}
}
//字典哈希表的扩展
int dictExpand(dict* d, unsigned long size)
{ // 不能在字典正在 rehash 时进行扩展表操作，size 的值也不能小于 0 号哈希表的当前已使用节点
	if (dictIsRehashing(d) || d->ht[0].used > size)
		return DICT_ERR;
	dictht n;//新哈希表
	unsigned long realsize = dictNextPower(size);
	//确定新哈希表大小
	n.size = realsize;
	n.sizemask = realsize - 1;
	//为1号哈希表分配内存空间
	n.table = (dictEntry**)calloc(realsize ,sizeof(dictEntry*));
	n.used = 0;
	//0号哈希表为空，那么这是一次初始化
	if (d->ht[0].table == NULL)
	{
		d->ht[0] = n;
	} // 0号哈希表不空, 那么这是一次rehash
	else
	{
		d->ht[1] = n;
		d->rehashidx = 0;
	}
	return DICT_OK;
}
//根据需要，初始化字典（的哈希表），或者对字典（的现有哈希表）进行扩展
static int dictExpandIfNeeded(dict* d)
{
	// 渐进式 rehash 已经在进行了，不能扩展和初始化 直接返回
	if (dictIsRehashing(d))
		return DICT_OK;//返回ok

	// 如果字典（的 0 号哈希表）为空，那么创建并返回初始化大小的 0 号哈希表
	if (d->ht[0].size == 0)
		return dictExpand(d, DICT_HT_INITIAL_SIZE);

	// 一下两个条件之一为真时，对字典进行扩展
	//1）字典已使用节点数和字典大小之间的比率接近 1：1，并且 dict_can_resize 为真
	//2）已使用节点数和字典大小之间的比率超过 dict_force_resize_ratio
	if (d->ht[0].used >= d->ht[0].size && (dict_can_resize || d->ht[0].used / d->ht[0].size > dict_force_resize_ratio))
	{
		// 新哈希表的大小至少是目前已使用节点数的两倍
		return dictExpand(d, d->ht[0].used * 2);
	}
	//返回ok标志
	return DICT_OK;
}

5)字典哈希表缩减函数

//缩小字典的哈希表
int dictResize(dict* d)
{

	//新表所需结点的最小数量
	int minimal;
	// 不能在关闭 rehash 或者正在 rehash 的时候调用
	if (!dict_can_resize || dictIsRehashing(d)) return DICT_ERR;

	// 计算让比率接近 1：1 所需要的最少节点数量
	minimal = d->ht[0].used;
	if (minimal < DICT_HT_INITIAL_SIZE)
		minimal = DICT_HT_INITIAL_SIZE;
	// 调整字典的大小
	return dictExpand(d, minimal);
}

6）哈希表键和值的查找函数(注释与上相同)

//查找键(注释与上类似)
dictEntry* dictFind(dict* d, const void* key)
{
	dictEntry* he;
	unsigned int h, idx, table;
	if (d->ht[0].used == 0)
	{
		return NULL;
	}
	if (dictIsRehashing(d))dictRehashStep(d);
	h = dictHashKey(d, key);//计算哈希值
	for (table = 0; table < 1; table++)
	{
		idx = h & d->ht[table].sizemask;//计算索引值
		he = d->ht[table].table[idx];//获取哈希表索引上的节点
		while (he)
		{
			if (dictCompareKeys(d, key, he->key))
				return he;

			he = he->next;
		}
		if (!dictIsRehashing(d))return NULL;
	}
	return NULL;
}
//查找值
void *dictFetchVslue(dict* d, const void* key)
{
	dictEntry* he;
	//根据键查找在字典中是否存在
	he = dictFind(d, key);
	//若存在返回该节点的值，反之返回NULL
	return he ? dictGetVal(he) : NULL;//dictGetVal为宏定义
}

7）查找并删除给定键的函数(注意:头部节点特殊处理)

//查找并删除给定键的节点
//参数 nofree 决定是否调用键和值的释放函数
//0 表示调用，1 表示不调用
static int dictGenericDelete(dict* d, const void* key, int nofree)
{
	unsigned int h, idx;
	dictEntry* he, * prevHe;
	int table;
	if (d->ht[0].size == 0)
	{
		return DICT_ERR;
	}

	if (dictIsRehashing(d))dictRehashStep(d);
	h = dictHashKey(d, key);
	for (table = 0; table < 1; table++)
	{
		idx = h & d->ht[0].sizemask;
		he = d->ht[table].table[idx];
		prevHe = NULL;
		while (he)
		{
			if (dictCompareKeys(d, key, he->key))
			{
				if (prevHe)
				{//删除头部之后的节点
					prevHe->next = he->next;
				}
				else
				{//删除头部节点
					d->ht[table].table[idx] = he->next;
				}
				//如果需要释放，则调用键和值的释放函数
				if (!nofree)
				{
					dictFreeKey(d, he);
					dictFreeVal(d, he);
				}
				free(he);
				d->ht[table].used--;
				return DICT_OK;
			}
			prevHe = he;
			he = he->next;
		}
		//程序只想到此处，说明在0号哈希表中没有该节点，
		//此时判断是否正在rehash，若没有进行Rehash，则不用再继续找了，否则在1号哈希表中继续找
		if (!dictIsRehashing(d))
			break;
	}
	return DICT_ERR;
}
//删除键
int dictDelete(dict* ht, const void* key)
{
	return dictGenericDelete(ht, key, 0);
}

在这里插入图片描述

8)清空哈希表

//删除哈希表上的所有节点
int dictClear(dict* d, dictht* ht)
{
	unsigned long i;
	for (i = 0; i < ht->size && ht->used>0; i++)
	{
		dictEntry* he, * nextHe;
		if ((he = ht->table[i]) == NULL)continue;
		while (he != NULL)
		{
			nextHe = he->next;
			dictFreeKey(d, he);//删除键
			dictFreeVal(d, he);//删除值
			free(he);
			ht->used--;
			he = nextHe;
		}
	}
	free(ht->table);//释放哈希表结构
	dictReset(ht);//重置哈希表属性
	return DICT_OK;
}

9）清空并释放整个字典

//删除并释放整个字典
void dictRelease(dict* d)
{//删除并释放两个哈希表结构
	dictClear(d, &d->ht[0]);
	dictClear(d, &d->ht[1]);
	//释放字典结构
	free(d);
}
幽萌之雨
关注
  • 3
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
「Redis数据结构」哈希表（Dict）
frozenpenguin的博客
11-18 3632
哈希表中的每一个key 都是独一无二的，程序可以根据 key 查找到与之关联的 value，或者通过 key 来更新 value，又或者根据 key 来删除整个 key-value等等。哈希表优点在于，它能以 O(1) 的复杂度快速查询数据。怎么做到的呢？将 key 通过 Hash 函数的计算，就能定位数据在表中的位置，因为哈希表实际上是数组，所以可以通过索引值快速查询到数据。但是存在的风险也是有，在哈希表大小固定的情况下，随着数据不断增多，那么哈希冲突的可能性也会越高。解决哈希冲突的方式，有很多种。
redis源码解析 hash字典- dict （6.2.3版本）
qazwsxwtc的专栏
08-04 258
hash字典，kv存储，用于快速查询，redis中的源码为 dict.h和dict.c， redis hash字典采用渐进式hash实现，具体渐进式hash，请搜索相关博文阅读。 redishash字典的结构体声明 typedef struct dictEntry {//字典实体节点 void *key; //字典实体节点key union { void *val; uint64_t u64; int64_t s64; .
哈希字典Dict
m0_57408211的博客
04-07 739
在进行 rehash 期间，每次对字典执行 增、删、改、查操作时，程序除了执行指定的操作外，还会将 哈希表 ht[0].table中下标为 rehashidx 位置上的所有的键值对 全部迁移到 ht[1].table 上，完成后 rehashidx 自增。其实没有想象中的那么复杂，随着字典操作的不断执行，哈希表保存的键值对会不断增多（或者减少），为了让哈希表的负载因子维持在一个合理的范围之内，当哈希表保存的键值对数量太多或者太少时，需要对哈希表大小进行扩展或者收缩。，数组的每个元素称为一个哈希桶。
python hash及dict()实现原理
纸上得来终觉浅，绝知此事要躬行！
11-28 1157
文章目录python hash及dict()实现原理refnote python hash及dict()实现原理 哈希（散列） dict() 实现原理 ref Python 中的哈希表：对字典的理解 Python之哈希表 hash 定义 力扣应用 note 哈希操作： f(x)−−−>yf(x) ---> yf(x)−−−>y f()f()f()：哈希函数 yyy：哈希值 单向不可逆 当不同xxx经过哈希操作后得到了相同的哈希值yyy，则叫做冲突 解决冲突： op
128. 最长连续序列
Tzecto
08-13 390
最长连续序列 给定一个未排序的整数数组 nums ，找出数字连续的最长序列（不要求序列元素在原数组中连续）的长度。 请你设计并实现时间复杂度为 O(n) 的算法解决此问题。 示例 1： 输入：nums = [100,4,200,1,3,2] 输出：4 解释：最长数字连续序列是 [1, 2, 3, 4]。它的长度为 4。 示例 2： 输入：nums = [0,3,7,2,5,8,4,6,0,1] 输出：9 class Solution { public: int longestConsecut.
hashdict.c:这是我用 150 行代码在 C 语言中非常快速地实现了一个哈希表
05-29
哈希字典 这是我用200行代码在C中实现哈希表的真正快速实现。...# include " hashdict.h " int main () { struct dictionary* dic = dic_new ( 0 ); dic_add (dic, " ABC " , 3 ); *dic-> value = 100 ;
HashDict:超快速哈希破解字典攻击
04-11
HashDict 超快速哈希破解字典攻击 目录 基本信息 HashDict使用很少的cpu和内存，并且仍然非常快速地通过单词表。 设置 Hashdict可在具有python3的任何平台上运行，并且设置起来非常简单。 $ git clone ...
simple_dict:简单非常简单的hashdict C实现
04-02
哈希表的实现 ...实施HASH算法 除法哈希和线性探测 待办事项清单 完善文档，添加对字典的引用 添加makefile以创建一个库 清理代码并设置不同的样式，现在它在llvm中 依存关系 对于运行测试， 参考 去做
Python 的字典（Dict）是如何存储的
09-19
### Python字典（Dict）的存储机制详解 #### 前言 在深入探讨Python字典的存储原理之前，我们先来明确几个概念。字典是Python中的一种内置数据结构，它以键值对的形式存储数据。由于其高效的数据查找性能，字典被...
基于Python __dict__与dir()的区别详解
09-21
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__...
PHP hash dict,python dict字典详细说明
weixin_33914679的博客
03-21 168
字典是通过hash表的原理实现的，每个元素都是一个键值对，通过元素的键计算出一个唯一的哈希值，这个hash值决定了元素的地址，因此为了保证元素地址不一样，必须保证每个元素的键和对应的hash值是完全不同的，并且键的类型必须是不可修改的，所以键的类型可以使数值，字符串常量或元组，但不能是列表，因为列表是可以被修改的。所以字典具有下列特性：1、元素的查询和插入操作很快，基本上是常数级别2、占用内存较大...
关于Python中的字典(映射、哈希、散列)理解
热门推荐
一只小蜗牛 爬呀爬
03-20 2万+
[转] 原文地址:小甲鱼 关于dict Python 的字典中有很多名字(“映射”、”哈希”、”散列”和”关系数组”)，那你知道为什么字典会被称为Hash吗？你知道为什么字典对于键Key的存储要求很严格，但对于对应的值Value的存储却要求很宽松吗？ 引用：WIKI词条 A hash function is any function that can be used to...
dict, hash
weixin_38170853的博客
08-05 95
dict： 　　dictKey -- > dictVal example: dictEntry *dictFind(dict *d, const void *key) Keyis like a index whichto find the real entry. how to find: 　　depend onthe construction ...
Redis源码分析（三）---dict哈希结构
走在前往架构师的路上
10-07 1万+
昨天分析完adlist的Redis代码，今天马上马不停蹄的继续学习Redis代码中的哈希部分的结构学习，不过在这里他不叫什么hashMap，而是叫dict，而且是一种全新设计的一种哈希结构，他只是通过几个简单的结构体，再搭配上一些比较常见的哈希算法，就实现了类似高级语言中HashMap的作用了。也让我见识了一些哈希算法的实现，比如dbj hash的算法实现，俗称times33,算法，就是不停的*3
Python教程之字典（基于Python3.8）（三）
MELF晓宇的博客
09-29 915
字典 字典是一种可变容器模型，且可存储任意类型对象。 字典的每个键值 key=>value 对用冒号 : 分割，每个对之间用逗号(,)分割，整个字典包括在花括号 {} 中 ,格式如下所示： d = {key1 : value1, key2 : value2 } 键必须是唯一的，但值则不必。 值可以取任何数据类型，但键必须是不可变的，如字符串，数字。 新建 # 创建一个空字典 dic = {} print(dic, type(dic)) # 创建一个字典 # 直接创建 dic0 = {"Name":
python dict的hash实现原理及细节
aglxw2012的博客
07-11 415
pass 转载于:https://www.cnblogs.com/zhang-xiaoyu/p/9296220.html
Redis源码学习简记（三）dict哈希原理与个人理解
菜鸟的学习之路
04-08 909
Redis哈希的实现比较难理解，为了提升性能，采用分治的思想。当哈希桶需要扩容的时候，并不是直接全部更新，而是定义两个哈希表，新表旧表。当处于扩容状态时，每进行一次插入或查找操作就进行一次更新操作，即把原始表的一个数据移到新的表中。当所有数据迁移完成后，新表变成旧表，旧表变成新表。这样在扩容的过程就变成了分步进行。减少了因扩容而产生的长时间等待。具体的实现，代码见，仔细看了代码后，了解会深很多。先...
python算法与数据结构（11）使用hash表实现dict
qq_36710311的博客
03-05 195
使用hash表实现dict ADT HASH表代码拷贝过来 class Array(object): def __init__(self, size=32, init=None): self._size = size self._items = [None] * size def __getitem__(self, index): ...
数字签名技术为何要使用hash算法_小猿圈 python学习-hash是个什么东西
weixin_39946274的博客
01-29 1365
什么是哈希？hash,一般翻译做散列、杂凑，或音译为哈希，是把任意长度的输入(又叫做预映射pre-image)通过散列算法变换成固定长度的输出，该输出就是散列值。这种转换是一种压缩映射，也就是，散列值的空间通常远小于输入的空间。 它其实就是一个算法，最简单的算法就是加减乘除，比方，我设计个数字算法，输入+7=输出，比如我输入1，输出为8；输入2，输出为9。哈希算法不过是一个更为复杂的运算，它的输入...
python type dict
最新发布
06-19
它是哈希表（Hash Table）的实现，用于存储键值对（Key-Value Pairs），其中每个键（Key）都是唯一的，对应一个值（Value）。这是一种非常高效的数据结构，因为它支持常数时间复杂度（O(1)）的查找、插入和删除操作...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值