各种hash哈希

最新推荐文章于 2024-05-13 17:21:47 发布
最新推荐文章于 2024-05-13 17:21:47 发布
阅读量1k 收藏
点赞数
分类专栏： 资料
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/luyuncheng/article/details/8201364
版权

据说，Hash的优劣顺序为：BKDRHash, APHash, DJBHash, JSHash, RSHash, SDBMHash, PJWHash, ELFHash。应该是从速度区分吧。因为BKDRHash最快（据说也最好背），ELFHash最准确（冲突率最低）。


unsigned  int  SDBMHash( char  *str)  
  
  
{  
    unsigned int  hash =  0 ;  
   
    while  (*str)  
    {  
        // equivalent to: hash = 65599*hash + (*str++);   
        hash = (*str++) + (hash << 6 ) + (hash <<  16 ) - hash;  
    }  
   
    return  (hash &  0x7FFFFFFF );  
}  
   
// RS Hash    
unsigned int  RSHash( char  *str)  
{  
    unsigned int  b =  378551 ;  
    unsigned int  a =  63689 ;  
    unsigned int  hash =  0 ;  
   
    while  (*str)  
    {  
        hash = hash * a + (*str++);  
        a *= b;  
    }  
   
    return  (hash &  0x7FFFFFFF );  
}  
   
// JS Hash    
unsigned int  JSHash( char  *str)  
{  
    unsigned int  hash =  1315423911 ;  
   
    while  (*str)  
    {  
        hash ^= ((hash << 5 ) + (*str++) + (hash >>  2 ));  
    }  
   
    return  (hash &  0x7FFFFFFF );  
}  
   
// P. J. Weinberger Hash    
unsigned int  PJWHash( char  *str)  
{  
    unsigned int  BitsInUnignedInt = (unsigned  int )(sizeof(unsigned  int ) *  8 );  
    unsigned int  ThreeQuarters  = (unsigned  int )((BitsInUnignedInt  *  3 ) /  4 );  
    unsigned int  OneEighth = (unsigned  int )(BitsInUnignedInt /  8 );  
    unsigned int  HighBits = (unsigned  int )( 0xFFFFFFFF ) << (BitsInUnignedInt   
  
                                               - OneEighth);  
    unsigned int  hash   =  0 ;  
    unsigned int  test   =  0 ;  
   
    while  (*str)  
    {  
        hash = (hash << OneEighth) + (*str++);  
        if  ((test = hash & HighBits) !=  0 )  
        {  
            hash = ((hash ^ (test >> ThreeQuarters)) & (~HighBits));  
        }  
    }  
   
    return  (hash &  0x7FFFFFFF );  
}  
   
// ELF Hash    
unsigned int  ELFHash( char  *str)  
{  
    unsigned int  hash =  0 ;  
    unsigned int  x  =  0 ;  
   
    while  (*str)  
    {  
        hash = (hash << 4 ) + (*str++);  
        if  ((x = hash & 0xF0000000L) !=  0 )  
        {  
            hash ^= (x >> 24 );  
            hash &= ~x;  
        }  
    }  
   
    return  (hash &  0x7FFFFFFF );  
}  
   
// BKDR Hash    
unsigned int  BKDRHash( char  *str)  
{  
    unsigned int  seed =  131 ;  // 31 131 1313 13131 131313 etc..   
    unsigned int  hash =  0 ;  
   
    while  (*str)  
    {  
        hash = hash * seed + (*str++);  
    }  
   
    return  (hash &  0x7FFFFFFF );  
}  
   
// DJB Hash    
unsigned int  DJBHash( char  *str)  
{  
    unsigned int  hash =  5381 ;  
   
    while  (*str)  
    {  
        hash += (hash << 5 ) + (*str++);  
    }  
   
    return  (hash &  0x7FFFFFFF );  
}  
   
// AP Hash    
unsigned int  APHash( char  *str)  
{  
    unsigned int  hash =  0 ;  
    int  i;  
   
    for  (i= 0 ; *str; i++)  
    {  
        if  ((i &  1 ) ==  0 )  
        {  
            hash ^= ((hash << 7 ) ^ (*str++) ^ (hash >>  3 ));  
        }  
        else   
        {  
            hash ^= (~((hash << 11 ) ^ (*str++) ^ (hash >>  5 )));  
        }  
    }  
   
    return  (hash &  0x7FFFFFFF );  
}

java hashmap 

    package  com.hash.test;  
      
    public   class  TestHash {  
      
        public   static   int  BKDRHash(String str) {  // BKDR Hash Function   
      
            int  seed =  31 ;  // 31 131 1313 13131 131313 etc..   
            int  hash =  0 ;  
            int  i =  0 ;  
            while  (i < str.length()) {  
                hash = hash * seed + str.charAt(i);  
                i++;  
            }  
            // return (hash & 0x7FFFFFFF);   
            return  hash;  
        }  
      
        public   static  String[] data =  new  String[ 20 ];  
      
        public   static   void  put(String str) {  
            int  key = BKDRHash(str) %  20 ;  
            System.out.println(key);  
            data[key] = str;  
        }  
      
        /**  
         * Test  
         */   
        public   static   void  main(String[] args) {  
      
            String str = "key" ;  
            for  ( int  i =  0 ; i <  20 ; i++) {  
                put(str + i);  
            }  
            System.out.println(data[BKDRHash(str + 1 ) %  20 ]);  
      
        }  
      
    }  

package com.hash.test;

public class TestHash {

	public static int BKDRHash(String str) { // BKDR Hash Function

		int seed = 31; // 31 131 1313 13131 131313 etc..
		int hash = 0;
		int i = 0;
		while (i < str.length()) {
			hash = hash * seed + str.charAt(i);
			i++;
		}
		// return (hash & 0x7FFFFFFF);
		return hash;
	}

	public static String[] data = new String[20];

	public static void put(String str) {
		int key = BKDRHash(str) % 20;
		System.out.println(key);
		data[key] = str;
	}

	/**
	 * Test
	 */
	public static void main(String[] args) {

		String str = "key";
		for (int i = 0; i < 20; i++) {
			put(str + i);
		}
		System.out.println(data[BKDRHash(str + 1) % 20]);

	}

}
模板化 

/// @brief BKDR Hash Function
/// @detail 本算法由于在Brian Kernighan与Dennis Ritchie的《The C Programming Language》一书被展示而得名，是一种简单快捷的hash算法，也是Java目前采用的字符串的Hash算法（累乘因子为31）。
template<class T>
size_t BKDRHash(const T *str)
{
	register size_t hash = 0;
	while (size_t ch = (size_t)*str++)
	{		
		hash = hash * 131 + ch;   // 也可以乘以31、131、1313、13131、131313..
		// 有人说将乘法分解为位运算及加减法可以提高效率，如将上式表达为：hash = hash << 7 + hash << 1 + hash + ch;
		// 但其实在Intel平台上，CPU内部对二者的处理效率都是差不多的，
		// 我分别进行了100亿次的上述两种运算，发现二者时间差距基本为0（如果是Debug版，分解成位运算后的耗时还要高1/3）；
		// 在ARM这类RISC系统上没有测试过，由于ARM内部使用Booth's Algorithm来模拟32位整数乘法运算，它的效率与乘数有关：
		// 当乘数8-31位都为1或0时，需要1个时钟周期
		// 当乘数16-31位都为1或0时，需要2个时钟周期
		// 当乘数24-31位都为1或0时，需要3个时钟周期
		// 否则，需要4个时钟周期
		// 因此，虽然我没有实际测试，但是我依然认为二者效率上差别不大		
	}
	return hash;
}
/// @brief SDBM Hash Function
/// @detail 本算法是由于在开源项目SDBM（一种简单的数据库引擎）中被应用而得名，它与BKDRHash思想一致，只是种子不同而已。
template<class T>
size_t SDBMHash(const T *str)
{
	register size_t hash = 0;
	while (size_t ch = (size_t)*str++)
	{
		hash = 65599 * hash + ch;		
		//hash = (size_t)ch + (hash << 6) + (hash << 16) - hash;
	}
	return hash;
}
/// @brief RS Hash Function
/// @detail 因Robert Sedgwicks在其《Algorithms in C》一书中展示而得名。
template<class T>
size_t RSHash(const T *str)
{
	register size_t hash = 0;
	size_t magic = 63689;	
	while (size_t ch = (size_t)*str++)
	{
		hash = hash * magic + ch;
		magic *= 378551;
	}
	return hash;
}
/// @brief AP Hash Function
/// @detail 由Arash Partow发明的一种hash算法。
template<class T>
size_t APHash(const T *str)
{
	register size_t hash = 0;
	size_t ch;
	for (long i = 0; ch = (size_t)*str++; i++)
	{
		if ((i & 1) == 0)
		{
			hash ^= ((hash << 7) ^ ch ^ (hash >> 3));
		}
		else
		{
			hash ^= (~((hash << 11) ^ ch ^ (hash >> 5)));
		}
	}
	return hash;
}
/// @brief JS Hash Function
/// 由Justin Sobel发明的一种hash算法。
template<class T>
size_t JSHash(const T *str)
{
	if(!*str)		 // 这是由本人添加，以保证空字符串返回哈希值0
		return 0;
	register size_t hash = 1315423911;
	while (size_t ch = (size_t)*str++)
	{
		hash ^= ((hash << 5) + ch + (hash >> 2));
	}
	return hash;
}
/// @brief DEK Function
/// @detail 本算法是由于Donald E. Knuth在《Art Of Computer Programming Volume 3》中展示而得名。
template<class T>
size_t DEKHash(const T* str)
{
	if(!*str)		 // 这是由本人添加，以保证空字符串返回哈希值0
		return 0;
	register size_t hash = 1315423911;
	while (size_t ch = (size_t)*str++)
	{
		hash = ((hash << 5) ^ (hash >> 27)) ^ ch;
	}
	return hash;
}
/// @brief FNV Hash Function
/// @detail Unix system系统中使用的一种著名hash算法，后来微软也在其hash_map中实现。
template<class T>
size_t FNVHash(const T* str)
{
	if(!*str)	// 这是由本人添加，以保证空字符串返回哈希值0
		return 0;
	register size_t hash = 2166136261;
	while (size_t ch = (size_t)*str++)
	{
		hash *= 16777619;
		hash ^= ch;
	}
	return hash;
}
/// @brief DJB Hash Function
/// @detail 由Daniel J. Bernstein教授发明的一种hash算法。
template<class T>
size_t DJBHash(const T *str)
{
	if(!*str)	// 这是由本人添加，以保证空字符串返回哈希值0
		return 0;
	register size_t hash = 5381;
	while (size_t ch = (size_t)*str++)
	{
		hash += (hash << 5) + ch;
	}
	return hash;
}
/// @brief DJB Hash Function 2
/// @detail 由Daniel J. Bernstein 发明的另一种hash算法。
template<class T>
size_t DJB2Hash(const T *str)
{
	if(!*str)	// 这是由本人添加，以保证空字符串返回哈希值0
		return 0;
	register size_t hash = 5381;
	while (size_t ch = (size_t)*str++)
	{
		hash = hash * 33 ^ ch;
	}
	return hash;
}
/// @brief PJW Hash Function
/// @detail 本算法是基于AT&T贝尔实验室的Peter J. Weinberger的论文而发明的一种hash算法。
template<class T>
size_t PJWHash(const T *str)
{
	static const size_t TotalBits		= sizeof(size_t) * 8;
	static const size_t ThreeQuarters	= (TotalBits  * 3) / 4;
	static const size_t OneEighth		= TotalBits / 8;
	static const size_t HighBits		= ((size_t)-1) << (TotalBits - OneEighth);	
	
	register size_t hash = 0;
	size_t magic = 0;	
	while (size_t ch = (size_t)*str++)
	{
		hash = (hash << OneEighth) + ch;
		if ((magic = hash & HighBits) != 0)
		{
			hash = ((hash ^ (magic >> ThreeQuarters)) & (~HighBits));
		}
	}
	return hash;
}
/// @brief ELF Hash Function
/// @detail 由于在Unix的Extended Library Function被附带而得名的一种hash算法，它其实就是PJW Hash的变形。
template<class T>
size_t ELFHash(const T *str)
{
	static const size_t TotalBits		= sizeof(size_t) * 8;
	static const size_t ThreeQuarters	= (TotalBits  * 3) / 4;
	static const size_t OneEighth		= TotalBits / 8;
	static const size_t HighBits		= ((size_t)-1) << (TotalBits - OneEighth);	
	register size_t hash = 0;
	size_t magic = 0;
	while (size_t ch = (size_t)*str++)
	{
		hash = (hash << OneEighth) + ch;
		if ((magic = hash & HighBits) != 0)
		{
			hash ^= (magic >> ThreeQuarters);
			hash &= ~magic;
		}		
	}
	return hash;
}


luyuncheng
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Ruby中的Hash哈希类型基本操作方法小结
09-21
下面是关于Ruby中Hash哈希类型的一些基本操作方法的详细解释： 1. 创建哈希： - `Hash.new` 用于创建一个新的空哈希，默认值为 `nil`。 - `Hash.new("This is my first hash instance")` 创建一个空哈希，其...
链式哈希表hash
11-16
哈希表（Hash Table）的核心思想是通过哈希函数将数据的关键字（key）映射到一个固定大小的数组中，使得查找、插入和删除操作的时间复杂度可以接近O(1)。 哈希函数是链式哈希表中的关键部分，它的主要任务是将...
hash哈希
可乐不解渴
02-16 551
hash哈希哈希概念哈希冲突哈希函数哈希冲突解决闭散列开散列哈希表的闭散列实现哈希表闭散列结构哈希表的闭散列插入哈希表的闭散列查找哈希表的闭散列删除哈希表的开散列实现哈希表的开散列结构哈希表的开散列插入哈希表的开散列查找哈希表的开散列删除 人间四月芳菲尽，山寺桃花始盛开。 哈希概念 顺序结构以及平衡树中，元素关键码与其存储位置之间没有对应的关系，因此在查找一个元素时，必须要经过关键码的多次比较。搜索的效率取决于搜索过程中元素的比较次数，因此顺序结构中查找的时间复杂度为O (N) ，AVL树与红黑树中查找的时
各种字符串Hash函数比较
uiiの技术随笔
03-08 880
装载自：http://www.byvoid.com/blog/string-hash-compare/ 常用的字符串Hash函数还有ELFHash，APHash等等，都是十分简单有效的方法。这些函数使用位运算使得每一个字符都对最后的函数值产生影响。另外还有以MD5和SHA1为代表的杂凑函数，这些函数几乎不可能找到碰撞。 常用字符串哈希函数有BKDRHash，APHash，DJBHa
hash算法比较
最新发布
木牛的博客
05-13 34
常用的算法有BKDRHash，APHash，DJBHash，JSHash，RSHash，SDBMHash，PJWHash，ELFHash等。
常见的三种哈希结构
unspoken0714的博客
11-07 614
查询一个元素是否出现在集合中的快速方法，哈希表 一般会使用如下三种数据结构 数组 set map set c++中对于set提供了三种数据结构 集合 底层实现 是否有序 数值是否可以重复 是否能更改数值 查询效率 增删效率 std::set 红黑树 有序 否 否 O(logn) O(logn) std::multiset 红黑树 有序 是 否 O(logn) O(logn) std::unordered_set 哈希表 无序 否 否 O(1) O(1) map 集合
【数据结构】哈希（Hash）
秋之回忆Alex的博客
09-02 6381
数据结构：哈希函数
什么是Hash(哈希)？
热门推荐
qq_48826531的博客
07-21 1万+
概念哈希即可以是一种数据结构，也可以是一种函数概念，那么在查找时通过该函数可以很快找到该元素。哈希()方法，哈希方法中使用的转换函数称为，构造出来的结构称为哈希算法不过是一个均匀的运算，它的输入可以是字符串，可以是数据，可以是任何文件，经过哈希运算后，变成一个固定长度的输出，该输出就是哈希值。但是哈希算法有一个很大的特点，...
HashTools哈希值计算工具
08-21
哈希值计算工具，如HashTools，是IT领域中一种重要的数据校验工具。它能够对文件内容进行精确的计算，生成一个固定长度的哈希值，这个值就像文件的数字指纹，对于验证文件的完整性和原始性至关重要。在本篇文章中，...
Ruby中Hash哈希结构的基本操作方法小结
09-21
Hash是通过一个特定的函数，即哈希函数（hash function），将键映射到一个存储位置，以此实现快速查找。哈希函数通常是一个将任意大小的键转换为固定大小的索引的算法，如在上述例子中使用的`h(ki) = ki%5`。这种...
哈希算法Hash
10-01
哈希算法 Hash 哈希算法 Hash 是一种常用的数据加密技术，用于将任意长度的数据转换为固定长度的哈希值。哈希算法 Hash 的设计目的是为了实现数据的加密和身份验证。下面我们将对哈希算法 Hash 进行详细的介绍和...
jwHash：C的简单哈希表实现
02-20
C的简单哈希表实现。 我只想要一个简单直接的哈希表实现，就可以在任何平台上将其放入基于C的项目中。 我以前没有实现过其中一种，因此它可能太幼稚了，但看起来确实工作得很好。 注意：在HN上公开并看到其他哈希实现之后，我计划将代码重组为基于宏的样式，这样可以减少重复。 特征 您可以创建一个哈希表，并添加字符串，长整数，双精度值和指向该哈希表的指针，并以字符串或长整数为键。 您可以通过get函数检索字符串，长整数，双精度数和指针。 复制保存在哈希表中的所有字符串，并在检索时返回字符串的副本。 我在散列存储桶上添加了锁定，这只会对性能产生较小的影响，并允许安全地检索和存储键值对。 表现似乎还不错。 通过字符串键保存1,000,000个int值大约需要0.28秒，并且多线程性能随处理器数量的增加而非常接近。 建立和使用 在文件夹中键入make以生成代码。 键入./test以运行演示。
几个比较著名的哈希算法
07-07
几个比较著名的哈希算法，还有哈希算法的概念以及如何优化哈希值的分布，在日常软件开发中十分有用
常用Hash类别及三方库实现
yichudu
09-27 735
1.简介参考 simhash was developed by Moses Charikar and is described in his paper, Simhash Princeton Univ. Paper Simhash explained
hash()函数的实现
一缕阳光的博客
09-05 1486
输入参数都是字符串。 6种hash函数的实现以及使用方式： template<class T> size_t BKDRHash(const T * str) // 该效率最高 { register size_t hash = 0; while (size_t ch = (size_t)*str++) { hash = hash * 131 ...
hash数据类型
08-20 4779
hash数据类型 当缓存内容有多个字段，且回发生变化时，此时String类型就不适合了。 Hash数据类型还常用于商品缓存。 最基本的命令 #设值 hset key field vale #取值 hget key field #设置key为new101， 字段名为news_id，对应的值为101 hset new101 news_id 101 #设置key为new101， 字段名...
破解压缩包、pdf、word 密码【Hashcat + john the ripper】
qq_33177268的博客
12-23 5431
工具下载 hashcat john the ripper 命令介绍 rar 获取hash值 rar2john.exe xxxx.rar 破解密码到 password.txt hashcat.exe -m 13000 -w 4 -a 3 $rar5$16$b88c1d7d2c96dc9d1b1a5ccdc5c25d50$15$8f0b287c982535c868bbff486ee9acd2$8$43907bfa03430471 -o password.txt Word 获取word加密文件的
常见的哈希算法总结
卡多希y的博客
07-21 6721
Hmac算法就是一种基于密钥的消息认证码算法，它是一种更安全的消息摘要算法，在存储用户的口令时，通过加"盐"的方式可以抵御彩虹表的攻击，而这个"salt"就相当于Hmac算法里的认证码这也是Hmac算法的一个优势，一般情况下，Hmac算法总是和某种哈希算法配合起来使用的，而且输出的长度也和所配合的这种哈希算法长度一致。字符串长度为32的原因是无论你要加密的内容是什么，最后的输出长度都会像上图提到的输出长度一样，像MD5最终的输出长度为16字节，因为我将字节数组转换为了字符串，所以它的长度就变为了32。...
MurmurHash 哈希算法
09-02
MurmurHash是一种非加密型哈希函数，适用于一般的哈希检索操作。它由Austin Appleby在2008年发明，并已经发布到了公有领域(public domain)。与其他流行的哈希函数相比，MurmurHash在处理规律性较强的key时有更好的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值