哈希表之bkdrhash算法解析及扩展

最新推荐文章于 2023-10-27 14:19:38 发布
最新推荐文章于 2023-10-27 14:19:38 发布
阅读量3w 收藏 99
点赞数 32
分类专栏： c/c++ 文章标签： bkdrhash hash 哈希表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wanglx_/article/details/40400693
版权

             BKDRHASH是一种字符哈希算法,像BKDRHash，APHash，DJBHash，JSHash，RSHash，SDBMHash，PJWHash，ELFHash等等,这些都是比较经典的，通过http://blog.csdn.net/wanglx_/article/details/40300363（字符串哈希函数）这篇文章，我们可知道，BKDRHash是比较好的一个获取哈希值的方法。下面就讲解这个BKDRHash函数是如何推导实现的。

            当我看到BKDRHash的代码时，不禁就疑惑了，这里面有个常数Seed，取值为31、131等，为什么要这么取，我取其他的值不行吗？还有为什么要将每个字符相加，并乘以这个Seed？ 这些到底是什么含义？ 最后想了老半天都是不得其解，最后绕进素数里面出不来了……最后在一位牛人的指点下，才茅塞顿开，下面把我的想法和推导过程记录如下。

BKDRHash计算公式的推导

          由一个字符串（比如：ad）得到其哈希值，为了减少碰撞，应该使该字符串中每个字符都参与哈希值计算，使其符合雪崩效应，也就是说即使改变字符串中的一个字节，也会对最终的哈希值造成较大的影响。我们直接想到的办法就是让字符串中的每个字符相加，得到其和SUM，让SUM作为哈希值，如SUM（ad）= a+d;可是根据ascii码表得知a(97)+d(100)=b(98)+c(99)，那么发生了碰撞，我们发现直接求和的话会很容易发生碰撞，那么怎么办哪？我们可以对字符间的差距进行放大，乘以一个系数：

SUM(ad) =系数1 * a + 系数2 * d

SUM(bc)= 系数1 * b + 系数2 * c

系数1不等于系数2，这样SUM(ad)等于SUM(bc)的概率就会大大减小。

           可是我们的字符串不可能只有两位或者三位，我们也不可能为每个系数去人为的赋值，但是字符串中有位数的顺序，比如在”ab”中，b是第0位，a是第1位,那么我们可以用系数的n次方作为每个字符的系数，但这个系数不能为1:

SUM(ad) =系数^1 * a + 系数^0 * d

SUM(bc)= 系数^1 * b + 系数^0 * c

这样我们就大大降低了碰撞的发生，下面我们假设有个字符数组p，有n个元素，那么

即:

下面就是这个“系数”取值的问题，取什么值那？从上面的分析来看，取除1之外的什么值都可以，我们知道整数不是奇数就是偶数，为了便于推算我们将偶数分为2的幂的偶数和非2的幂的偶数，也就是分3种取值讨论

系数的推导

现在我们的任务是推导系数的值，分2的幂的偶数、非2的幂的偶数、奇数三个部分讨论。

 

a.      取2的幂

假如我们取32，也就是2^5，那么我们计算SUM(ad)和SUM(bc)结果如下:

结果不同，有效处理了碰撞。

但是当我们进一步测试会发现，当我们取SUM(ahijklmn)和SUM(hijklmn)时计算得:

取SUM(abhijklmn)和SUM(abchijklmn)时计算得:

 

SUM(abcdefghijklmn)和SUM(123456hijklmn)时计算得:

 

我们会发现，只要最末尾的”hijklmn”这几个字符不变，不管前面怎么变，得到的哈希值都是一样的，完全碰撞了！这是为什么那？

          首先哈希值SUM的存储类型用什么？当然用unsignedint ,因为值会很大，unsigned int 是32位，而只要计算就可能会溢出，CPU对于溢出的处理是抛弃最高位，比如两个unsigned int 的值相加结果为33位，那么最高位33位就会被抛弃，那么我们对上面的情况进行计算:

计算SUM(ahijklmn)和SUM(bhijklmn)：

SUM(ahijklmn)= 32^7*a + 32^6*h + 32^5*I + 32^4*j + 32^3*k + 32^2*l + 32^1*m + 32^0*n

SUM(bhijklmn)= 32^7*b + 32^6*h + 32^5*I + 32^4*j + 32^3*k + 32^2*l + 32^1*m + 32^0*n

将32换为2^5得：

SUM(ahijklmn)= 2^35*a + 2^30*h + 2^25*I + 2^20*j + 2^15*k + 2^10*l + 2^5*m + 2^0*n

SUM(bhijklmn)= 2^35*b + 2^30*h + 2^25*I + 2^20*j + 2^15*k + 2^10*l + 2^5*m + 2^0*n

由此可知SUM(ahijklmn)和SUM(bhijklmn)都大于unsignedint所能表达的最大值，所以需要抛弃最高位，也就是对0x100000000(也就是2^33)取余，根据同余定理：

(a+b)%m= (a%m + b%m)%m

(a*b)%m= (a%m * b%m)%m

可知

SUM(ahijklmn)%2^33 = (2^35*a% 2^33  +  2^30*h% 2^33  + … +  2^0*n%2^33)% 2^33

SUM(bhijklmn)%2^33 = (2^35*b % 2^33  +  2^30*h % 2^33  + … +  2^0*n%2^33) 2^33

2^35*a% 2^33和 2^35*b % 2^33 为零，所以因溢出被CPU舍弃，得

SUM(ahijklmn)%2^33 = (2^30*h% 2^33  + … +  2^0*n% 2^33) 2^33

SUM(bhijklmn)%2^33 = (2^30*h % 2^33  + … +  2^0*n% 2^33) 2^33

最终他们的哈希值为

SUM(ahijklmn)= 2^30*h + 2^25*I + 2^20*j + 2^15*k + 2^10*l + 2^5*m + 2^0*n

SUM(bhijklmn)= 2^30*h + 2^25*I + 2^20*j + 2^15*k + 2^10*l + 2^5*m + 2^0*n

所以SUM(ahijklmn)等于SUM(bhijklmn)，这就是为什么” hijklmn”不变时，不管前面是什么字符串都会被舍弃，得到一样的字符串。这里用的是32=2^5，只要你用2^n，n不管为多少都不行，都会因为字符串的长度达到一定值而造成前面的被舍弃，造成一直碰撞。

b.       取非2的幂的偶数

既然去取2的幂不行，那么我们取非2的幂的偶数，假如我们取6作为系数，6为2^2+2，我们由上面取2的幂的推导可知，当字符的长度大于等于33时，系数就会变为6^32 ，可知系数大于2^32，对2^33取余，被舍弃，那么造成只要后32个字符不变，前面不管有多少个同的字符，都会被舍弃，计算所得的哈希值也就一样。

由上面两块可知，系数取偶数行不通

c.      取奇数（大于1）

假如我们取9=2^3+1，9^2=81=80+1，9^3=729=728+1，… ，9^n=9^n-1+1，我们知道9的幂肯定是奇数，那么9^n-1肯定为偶数，由上面的推论可知字符串达到一定的长度时，偶数系数前面的字符是可以舍弃的，可是9^n=9^n-1+1，最后的1是永远不会被舍弃的，所以每个字符都会参与运算，取大于1的奇数可行。

 

结论

 

由上面三步的推导可知，这个系数应当选择大于1的奇数，这样可以很好的降低碰撞的几率，那么我们就可以根据上面推导的公式，用代码实现:

bkdrhash的初步代码实现如下:

 

#include <iostream>
#include <MATH.H>

unsigned int str_hash_1(const char* s)
{
	unsigned char *p = (unsigned char*)s;
	unsigned int hash = 0;
	unsigned int seed = 3;//3,5,7,9,...,etc奇数
	unsigned int nIndex = 0;
	unsigned int nLen = strlen((char*)p);
	while( *p )
	{
		hash = hash + pow(3,nLen-nIndex-1)*(*p);
		++p;
		nIndex++;
	}
	return hash;
}

int main(int argc, char* argv[])
{
	std::cout << str_hash_1("hijklmn")<<std::endl;
	std::cout << str_hash_1("bhijklmn")<<std::endl;
	getchar();
	return 0;
}

其实我们可以对代码进行简化，即利用递归进行实现，但是在使用bkdrhash时你会发现里面大多源码使用的都是特殊的奇数2^n-1，那是因为在CPU的运算中移位和减法比较快。代码如下:

 

 

#include <iostream>

unsigned int bkdr_hash(const char* key)
{
	char* str = const_cast<char*>(key);
			
	unsigned int seed = 31; // 31 131 1313 13131 131313 etc.. 37
	unsigned int hash = 0;
	while (*str)
	{
		hash = hash * seed + (*str++);
	}
	return hash;
}

int main(int argc, char* argv[])
{
	std::cout << bkdr_hash("hijklmn")<<std::endl;
	std::cout << bkdr_hash("bhijklmn")<<std::endl;
	getchar();
	return 0;
}

 

扩展

 

注意：即使最终求得的bkdrhash值几乎不会冲突碰撞，但他们都是很大的值，不可能直接映射到哈希数组地址上，所以一般都是直接对哈希数组大小取余，以余数作为索引地址，但是这就造成了，可能的地址冲突。bkdrhash值不一样，但是取余后得到的索引地址一样，也就是冲突，只是这种冲突的概率很小。对于哈希表不可能完全消除碰撞，只能降低碰撞的几率。作为对哈希知识的进一步熟悉，下面罗列几点提升哈希表效率的注意点:

1.选用的哈希函数

            哈希函数的目的就是为了产生譬如字符串的哈希值，让不同的字符串尽量产生不同的哈希值的函数就是好的哈希函数，完全不会产生相同的哈希函数就是完美的。

2.处理冲突的方法

         处理冲突的方法有多种，拉链法、线性探测等，我喜欢用拉链法

3.哈希表的大小

         这个哈希表的大小是固定的，但可以动态调整，也就是创建个新的数组，用旧的给新的循环重新计算Key赋值，删除旧的。但最好根据需求数据量设置足够大的初始值，防止动态调整的频繁，因为调整是很费时又费空间的。还有重要的是，这个哈希表的大小要设为一个质数，为什么是质数？因为质数只有1和它本身两个约数，当用bkdrhash算得的key对哈希表大小取余时，不会因为存在公约数而缩小余数的范围，如果余数范围缩小的话，就会加大碰撞的几率(说法有点牵强，知道的童鞋请给个合理的解释)。

4.装载因子，即哈希表的饱和程度

一般来说装载因子越小越好，装载因子越小，碰撞也就越小，哈希表的速度就会越快，可是这样会大大的浪费空间，假如装载因子为0.1，那么哈希表只有10%的空间被真正利用，其余的90%都浪费了，这就是时间和空间的矛盾点，为了平衡，现在大部分采用的是0.75作为装载因子，装载因子达到0.75，那么就动态增加哈希表的大小。

哈希表的初步C++封装实现

 

//my_hash_map.h
//哈希表的初步实现
//参考互联网资料实现
#pragma once
#define HASH_MAX_STRING_LEN 128
#include <WINDOWS.H>
template<typename objectType> 
class my_strhash_map
{
protected:
	struct Assoc 
	{
		Assoc()
		{
			memset(sKey,0,HASH_MAX_STRING_LEN);
			pData = NULL;
			pNext = NULL;
		}
		char sKey[HASH_MAX_STRING_LEN];
		objectType* pData;
		Assoc* pNext;
	};

	typedef Assoc* LPAssoc;
public:
	struct iterator 
	{
		friend class my_strhash_map;
		iterator()
		{
			m_pIter = NULL;
			m_nIndex = 0;
			m_pMap = NULL;
		}
		//前缀，如++i
		iterator& operator++()
		{
			if ( m_pIter->pNext )
			{
				m_pIter = m_pIter->pNext;
				return *this
			}
			for ( ULONG i=m_nIndex+1; i<m_pMap->m_nHashSize; i++ )
			{
				if ( NULL != m_pMap->m_pHashTable[i] )
				{
					m_pIter = m_pMap->m_pHashTable[i];
					m_nIndex = i;
					return *this;
				}
			}
			m_pIter = NULL;
			m_nIndex = 0;
			return *this;
		}
		//后缀 如i++
		const iterator operator++(int)
		{
			iterator tmp( m_pIter,m_nIndex,m_pMap );
			if ( m_pIter->pNext )
			{
				m_pIter = m_pIter->pNext;
				return tmp;
			}

			for ( ULONG i=m_nIndex+1; i<m_pMap->m_nHashSize; i++ )
			{
				if ( NULL != m_pMap->m_pHashTable[i] )
				{
					m_pIter = m_pMap->m_pHashTable[i];
					m_nIndex = i;
					return tmp;
				}
			}
			m_pIter = NULL;
			m_nIndex = 0;
			return tmp;
		}
		objectType& operator *()
		{
			return *( m_pIter->pData );
		}
		bool operator== (const iterator& obj)
		{
			return m_pMap == obj.m_pMap && m_pIter == obj.m_pIter;
		}
		bool operator != (const iterator& obj)
		{
			return m_pMap != obj.m_pMap || m_pIter != obj.m_pIter;
		}
	protected:
		iterator(LPAssoc pAssoc,ULONG nIndex,my_strhash_map* map)
		{
			m_pIter = pAssoc;
			m_nIndex = nIndex;
			m_pMap = map;
		}
		LPAssoc m_pIter;
		ULONG m_nIndex;
		my_strhash_map* m_pMap;

	};
	my_strhash_map(ULONG nInitSize = 199,BOOL bAutoIncr = TRUE)
	{
		m_bAutoIncr = bAutoIncr;
		m_nHashSize = 0;
		m_nCount = 0;
		m_nConflictCount = 0;
		m_pHashTable = NULL;
		InitMap(nInitSize);
	}

	BOOL insert(const char* sKey,objectType obj)
	{
		if ( NULL == sKey || strlen(sKey) > HASH_MAX_STRING_LEN )
		{
			return FALSE;
		}

		ULONG nHash = BkdrHashKey(sKey) % m_nHashSize;
		LPAssoc pAssoc = m_pHashTable[nHash];
		if ( NULL == pAssoc )
		{
			m_pHashTable[nHash] = new Assoc;
			strcpy(m_pHashTable[nHash]->sKey,sKey);
			m_pHashTable[nHash]->pData = new objectType(obj);
			m_pHashTable[nHash]->pNext = NULL;
			m_nCount++;
		}
		else
		{
			LPAssoc pAssocPre = pAssoc;
			while( pAssoc )
			{
				//重复插入同一sKey，则返回
				if ( 0 == strcmp(pAssoc->sKey,sKey) )
					break;
				pAssocPre = pAssoc;
				pAssoc = pAssoc->pNext;
			}
			if ( NULL == pAssoc )
			{
				pAssoc = new Assoc;
				strcpy(pAssoc->sKey,sKey);
				pAssoc->pData = new objectType(obj);
				pAssoc->pNext = NULL;
				pAssocPre->pNext = pAssoc;
				m_nConflictCount++;
			}
		}

		if ( m_nCount > m_nHashSize )
		{
			ReSetTableSize( AdjustSize(m_nCount) );
		}
		return TRUE;
	}
	BOOL Find(const char* sKey,objectType& obj)
	{
		if ( NULL == sKey || strlen(sKey) > HASH_MAX_STRING_LEN )
		{
			return FALSE;
		}
		
		ULONG nHash = BkdrHashKey(sKey);
		nHash = nHash % m_nHashSize;
		LPAssoc pAssoc = m_pHashTable[nHash];
		while( pAssoc )
		{
			if ( 0 == strcmp(pAssoc.sKey,sKey) )
			{
				obj = *(pAssoc->pData);
				return TRUE;
			}
			pAssoc = pAssoc->pNext;
		}
		return FALSE;
	}
	BOOL Containts(const char* sKey)
	{
		if ( NULL == sKey || strlen(sKey) > HASH_MAX_STRING_LEN )
		{
			return FALSE;
		}

		ULONG nHash = BkdrHashKey(sKey);
		nHash = nHash % m_nHashSize;
		LPAssoc pAssoc = m_pHashTable[nHash];
		while( pAssoc )
		{
			if ( 0 == strcmp(pAssoc->sKey,sKey) )
				return TRUE;
			pAssoc = pAssoc->pNext;
		}
		return FALSE;
	}

	void RemoveKey(const char* sKey)
	{
		if ( NULL == sKey )
			return;
		ULONG nHash = BkdrHashKey(sKey)%m_nHashSize;
		LPAssoc pAssoc = m_pHashTable[nHash];
		if ( pAssoc && strcmp(pAssoc->sKey,sKey) == 0 )
		{
			m_pHashTable[nHash] = pAssoc->pNext;
			delete pAssoc->pData;
			delete pAssoc;
			m_nCount--;
		}
		else
		{
			LPAssoc pAssocPre = pAssoc;
			pAssoc = pAssoc->pNext;
			while( pAssoc )
			{
				if ( strcmp(pAssoc->sKey,sKey) == 0 )
				{
					pAssocPre->pNext = pAssoc->pNext;
					delete pAssoc->pData;
					delete pAssoc;
					m_nConflictCount--;
					break;
				}
				pAssocPre = pAssoc;
				pAssoc = pAssoc->pNext;
			}
		}
	}

	ULONG Size()
	{
		return m_nCount+m_nConflictCount;
	}
	void Clear()
	{
		LPAssoc pAssoc = NULL;
		LPAssoc pDelAssoc = NULL;
		for ( int i = 0;i < m_nHashSize;i++ )
		{
			pAssoc = m_pHashTable[i];
			while( pAssoc )
			{
				pDelAssoc = pAssoc;
				pAssoc = pAssoc->pNext;
				delete pDelAssoc->pData;
				delete pDelAssoc;
			}
			m_pHashTable[i] = NULL;
		}
		m_nCount = 0;
		m_nConflictCount = 0;
	}
	iterator begin()
	{
		for ( ULONG i=0; i<m_nHashSize; i++ )
		{
			if ( NULL != m_pHashTable[i] )
			{
				return iterator(m_pHashTable[i],i,this);
			}
		}
		return iterator(NULL,0,this);
	}
	iterator end()
	{
		return iterator(NULL,0,this);
	}
	ULONG GetTableSize()
	{
		return m_nHashSize;
	}
	BOOL AutoIncrease()
	{
		return m_bAutoIncr;
	}
protected:
 
	void ReSetTableSize(ULONG nSize)
	{
		LPAssoc* pNewAssocTable = new LPAssoc[nSize];
		memset( pNewAssocTable,0,sizeof((LPAssoc*)pNewAssocTable) );
		for ( ULONG i = 0;i < m_nHashSize;i++ )
		{
			LPAssoc pOldAssoc = m_pHashTable[i];
			while( NULL != pOldAssoc )
			{
				ULONG nHash = BkdrHashKey(pOldAssoc->sKey)%nSize;
				if ( NULL == pNewAssocTable[nHash] )
				{
					pNewAssocTable[nHash] = pOldAssoc;
					pNewAssocTable[nHash]->pNext = NULL;
				}
				else
				{
					LPAssoc pAssocTemp = pNewAssocTable[nHash];
					while( NULL != pAssocTemp->pNext )
						pAssocTemp = pAssocTemp->pNext;
					pAssocTemp->pNext = pOldAssoc;
					pAssocTemp->pNext->pNext = NULL;
				}
				pOldAssoc = pOldAssoc->pNext;
			}
		}

		delete[] m_pHashTable;
		m_pHashTable = pNewAssocTable;
		m_nHashSize = nSize;
	}
	void InitMap(ULONG nSize)
	{
		m_nHashSize = AdjustSize(nSize);
		if ( m_pHashTable )
		{
			delete[] m_pHashTable;
			m_pHashTable = NULL;
		}

		m_pHashTable = new LPAssoc[m_nHashSize];
		memset(m_pHashTable,0,sizeof(LPAssoc)*m_nHashSize );
	}
	ULONG AdjustSize(ULONG nSize)
	{
		// 注意：假设 long 至少有 32 bits。  
		//定义28个素数（大概是2倍关系增长），用来做hash table的大小
		const ULONG size_list[] = {
			53,			97,				193,		389,		769,
			1543,		3079,			6151,		12289,		24593,
			49157,		98317,			196613,		393241,		786443,
			1572869,	3145739,		6291469,	12582917,	25165842,
			50331553,	100663319,		201326611,	402653189,	805306457,
			1610612741,	3221225473ul,	4294967291ul
		};
		int nlistsize = sizeof(size_list) / sizeof(ULONG);
		int i = 0;
		for (;i<nlistsize;i++)
		{
			if ( size_list[i] >= nSize )
				break;
		}

		if ( i == nlistsize )
			i--;
		return size_list[i];
	}

	ULONG BkdrHashKey(const char* key) 
	{
		if (1)
		{
			char* str = const_cast<char*>(key);
			
			unsigned int seed = 31; // 31 131 1313 13131 131313 etc.. 37
			unsigned int hash = 0;
			
			while (*str)
			{
				hash = hash * seed + (*str++);
			}
			
			return (hash & 0x7FFFFFFF);
		}
		
		if ( NULL == key )
			return 0;
		ULONG nHash = 0;
		while (*key)
			nHash = (nHash<<5) + nHash + *key++;
		return nHash;
	}

protected:
	ULONG m_nHashSize;				//哈希表大小
	ULONG m_nCount;					//哈希表中当前元素个数
	ULONG m_nConflictCount;			//哈希表中冲突的个数
	LPAssoc* m_pHashTable;			//哈希表头指针
	BOOL m_bAutoIncr;				//是否自动调整表大小


};

 

 

 

 

 

wanglx2012
关注
  • 32
    点赞
  • 踩
  • 99
    收藏
    觉得还不错? 一键收藏
  • 9
    评论
专栏目录
C语言实现哈希表（源码+解析）
03-13
哈希表节点结构 struct Node：表示哈希表中的一个节点，包含键、值以及指向下一个节点的指针。 哈希表结构 struct HashTable：表示哈希表，包含一个存储节点指针的数组。 创建哈希表函数 createHashTable：动态分配哈希表的内存，并初始化哈希表数组为NULL。 哈希函数 hashCode：根据键计算哈希值，采用简单的求和取模的方式。 插入键值对函数 insert：根据键的哈希值确定存储位置，将新节点插入数组对应位置的链表头部。 查找键值对函数 get：根据键的哈希值确定存储位置，遍历链表查找对应的键，找到则返回对应的值，否则返回-1。 删除键值对函数 removeKey：根据键的哈希值确定存储位置，遍历链表查找并删除对应的键值对。 销毁哈希表函数 destroyHashTable：释放哈希表的内存，包括每个链表的节点和数组本身。
浅谈哈希表及哈希冲突.ppt
09-20
浅谈哈希表及哈希冲突
分布式哈希表(Distributed Hash Table DHT)1
08-03
1. 基础知识 3 2. 环的原子管理算法 4 3. 路由算法 10 4. 组通信算法 15 5. 副本管理算法 17 6. 分布式哈希表的应用 21 1. 基
[数据结构]哈希
Protein_zmm的博客
09-10 369
数据结构的哈希表相关概念及其实现
字符串哈希算法——BKDRHash
机器学习
09-01 4799
BYVoid对常用的几种字符串哈希函数进行了一次小小的评测。其评测结果，按照得分从高到低依次为BKDRHash，APHash，DJBHash，JSHash，RSHash，SDBMHash，PJWHash，ELFHash。其中，最优的字符串哈希算法BKDRHash函数实现如下： // BKDR Hash Function unsigned int BKDRHash(char *str) { ...
字符串哈希(BKDR_Hash)
日常记录，挨打要立正！
10-09 8268
详讲BKDR_Hash，并用C语言实现简版代码
【字符串哈希】 BKDR算法
天才小熊猫的博客
07-21 1301
给定一个字符串，问你子串S1[l1...r1] 与子串S2[l2...r2] 是否相等。 字符串哈希就是将字符串映射到整数，然后就和普通的哈希就一样了。 bkdr：hash[i] = (hash[i-1] * p +s[i] - 'a' + 1) % mod 一般取值：P = 13, mod = 101 #include<cstdio> #include&...
字符串哈希(BKDR_hash)
带你回江南的博客
06-27 1138
当我们要判断两个字符是否相等时，如S1="abc"，S2=“abb”。如果我们从头到尾逐个比较，则时间复杂度为O(m)。 这里我们就要用到字符串哈希来降到O(1)。 字符串哈希入门 说得通俗一点，字符串哈希实质上就是把每个不同的字符串转成不同的整数。 为什么会有这样的需要呢？很明显，存储一个超长的字符串和存储一个超大但是能存的下的整数，后者所占的空间会少的多，但主要还是为了方便判断一个字符串是否出现过，这是最基础的部分。 当然也很容易想到，如果有不同的字符串转成同一个整数，那么区分功能就基本废掉 ，所以我
字符串哈希bkdrhash原理及C语言实现
m0_50194941的博客
09-08 2293
#资料参考：https://blog.csdn.net/wanglx_/article/details/40400693?spm=1001.2014.3001.5501 要在学生管理系统中用到hash以提高查询速度，因此需要用到hash算法。经过查询，比较好用的字符串hash有bkdrhash，网上也有比较好的解析，因此选用这个算法进行应用。 首先介绍一下哈希及其算法。 Hash，一般翻译做散列、杂凑，或音译为哈希，是把任意长度的输入（又叫做预映射pre-image）通过散列算法变换成固定长度的输出，该输
golang 性能优化之累加哈希
weixin_34239592的博客
04-12 249
很多时候性能问题总是发生在一些不起眼的地方。最近做一个性能问题分析的时候发现，一个函数里面使用由于字符串拼接产生的临时字符串导致内存上涨了40%（120G 内存的机器），而这些临时字符串给 GC 也带来了非常大的负担，成为主要的性能瓶颈，而这些字符串作为 map 的 key，又必须要拼接，所以想到了直接使用 hash 后的值作为 map ...
hash.rar_HASH算法_fpga hash_hash_zebra85v_哈希表Verilog
07-14
哈希算法的高速FPGA实现，本文hi介绍，有少量算法介绍，共16页
算法学习：从头到尾彻底解析Hash-表算法
09-20
第一部分为一道百度面试题 Top K 算法的详解；第二部分为关于 Hash 表算法的详细阐述；第三部分为打造一个最快的 Hash 表算法。
字符串哈希【算法】
weixin_61907955的博客
06-01 4892
当一个字符串规模很大，并且需要多次访问该字符串或者子串的时候，我们可以用哈希函数对每个字符串进行哈希，分别映射到不同的数字中去，即一个整数哈希值，然后我们可以根据哈希值找到需要的字符串。哈希函数是哈希的关键，首先理论上任何一个函数都能做哈希函数，但是在字符串哈希中，为了避免冲突采用了一种进制哈希的方式（BKDRHash）。 原理：设定一个进制 P，需要计算一个字符串的哈希值时，把每个字符看成每个进制位上的一个数字，这个串转化成了一个基于进制 P 的数，最后对 M 取余数，就得到了这个字符串的哈希值。为简化计
字符串中的BKDRHash哈希函数
最新发布
「止于纸扇」的博客
10-27 118
字符串中的BKDRHash哈希函数详解
字符串哈希算法——BKDRHash之golang实现
小白菜的专栏
03-14 1566
package main import "fmt" func main() { hashValue := BKDRHash("Hello,World!") fmt.Print(hashValue) } func BKDRHash(str string) uint64 { seed := uint64(131) // 31 131 1313 13131 131313 etc.. has...
go语言数据结构第九篇-哈希表（散列）
junaozun的博客
04-26 1889
概念 哈希表是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做哈希表。 实际需求 google公司的一个上机题：基于哈希表的员工管理系统 有一个公司，当有新员工来报道时，要求将该员工的信息加入（id，名字），当输入该员工的id时，要求查找到该员工的所有信息。...
BKDRHash入门
Cheney的博客
12-12 1487
DKDRHash函数介绍 DKBRHash函数非常简单，我们只需要清楚基本原理就可以解决很多问题，当然不能避免所有的冲突，下图有大佬做的性能测试可知BKDDRHash函数的性能可见一斑。下面通过最简单的例子说明问题。 举例介绍 假设有如下字符串“abcd”，我们所做的就是寻找一个整数 i ，通过i可以直接访问到字符串，就好比数组一样，但是要保证这个 i 尽可能没有冲突，就是其他的字...
用哈希表嘞搜索人名算法
06-13
使用哈希表来实现人名搜索算法，可以高效地在大量的人名列表中进行查找。以下是一种可能的实现方法： 1. 将人名列表中的每个人名作为键，将对应的信息（如出生日期、地址等）作为值，构建一个哈希表。 2. 设计哈希函数，将人名转化为一个哈希值。一种简单的方法是将人名的每个字符的ASCII码相加，再取模得到哈希值。 3. 当需要搜索某个人名时，将该人名应用哈希函数，得到对应的哈希值，然后在哈希表中查找该键对应的值。 4. 如果哈希表中不存在该键，则说明该人名不存在；否则，返回对应的值，即该人的信息。 需要注意的是，由于哈希函数可能存在冲突，即不同的人名可能会得到相同的哈希值，因此需要在哈希表中处理冲突。一种简单的方法是使用开放寻址法，即当发生冲突时，依次查找下一个空闲位置，直到找到一个空闲位置为止。另一种方法是使用链表法，即在哈希表中为每个键维护一个链表，将哈希值相同的键放在同一个链表中。 使用哈希表进行人名搜索算法的时间复杂度为O(1)，即可以在常数时间内完成查找操作。因此，哈希表是一种高效的数据结构，适用于大量数据的查找场景。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值