关于Hash的总结

最新推荐文章于 2022-06-26 00:15:00 发布
原创 最新推荐文章于 2022-06-26 00:15:00 发布 · 1.7k 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#function #character #table #string #insert #tree

hash函数

  hash函数常用的是mod 素数，或者使用乘法策略，取某些位，这些策略直接影响到hash table的resize，如果是mod素数的话，只能按素数来递增，如果是取乘法方法，只能以2^p来递增。

  参考文献[1][2]等给出了很多，常用的字符串hash函数，但更有价值的还包括下面这两个：

  murmur hash[3][4]，其中[3]无法直接访问，不过本文的例子中有具体的实现，更多murmur hash[8]。

  city hash见参考文献[5]

hash table的构建

  hash table的构建通常使用list来解决冲突的问题，c++ tr1中就是这样的，tr1的实现中使用了策略base的设计方法，详情见参考文献[6]，目前没有仔细看。这个参考文献是在浏览的源码（ /usr/include/c++/4.4/tr1_impl/hashtable）时，在头注释中发现的。

resize问题

  resize的策略包括：

策略1：

 1）全部重新copy一遍，

策略2：

  1）resize时，使用2个hashtable，当insert时，只向新的hash table中insert，同时将old hash_table中的r个数据放如新的table；查找时，2个hash table同时查询

  2）如果old hash table数据已经全部移动完毕，删除old hash table

上面两个策略的详细信息见参考文献

bloomFilter

 说到hash需要提一下bloomfilter，它通过hash实现，好的hash函数可以使bloomfilter具有很好的性能。它的一个使用方法，就是如果要查询数据库，可以在数据库前加一个bloomfilter，如果没在bloomfilter中，就不用查询数据库了，因为bloomfilter返回false是不会有错误的。cityhash和murmurhash来实现bloomfilter应该是非常好的选择。

consistent hash（一致性hash）

  consistent hasn主要用于分布式系统，当增加或删除一个主机是，不会造成严重的抖动，因为他的策略只会导致相邻的一台主机rehash，因此影响比较小。参考文献[9]讲的也挺清楚的，值得参考。

C++中的hashtable

  C++ tr1中的hashtable实现是unordered_map，本文的例子和参考文献[10]，有简单的演示，我也看了部分unordered_map的实现，内部是hash_table实现的。其中参考文献[10]的参考文献给了更多有价值的参考信息。

本文的计算性能比较

代码如下： 
#include "basictypes.h"
#include <string>
#include <vector>
#include <stdlib.h>
#include <stdio.h>
#include <sys/time.h>
#include "cityhash/include/city.h"
#include <tr1/unordered_map>
#include <map>
// 64-bit hash for 64-bit platforms
const uint32 kFingerPrintSeed = 19820125;  
uint64 MurmurHash64A(const void* key, int len, uint32 seed) {
  const uint64 m = 0xc6a4a7935bd1e995;
  const int r = 47;

  uint64 h = seed ^ (len * m);

  const uint64* data = (const uint64 *)key;
  const uint64* end = data + (len/8);

  while (data != end) {
    uint64 k = *data++;

    k *= m;
    k ^= k >> r;
    k *= m;

    h ^= k;
    h *= m;
  }

  const uint8* data2 = (const uint8*)data;

  switch (len & 7) {
    case 7: h ^= static_cast<uint64>(data2[6]) << 48;
    case 6: h ^= static_cast<uint64>(data2[5]) << 40;
    case 5: h ^= static_cast<uint64>(data2[4]) << 32;
    case 4: h ^= static_cast<uint64>(data2[3]) << 24;
    case 3: h ^= static_cast<uint64>(data2[2]) << 16;
    case 2: h ^= static_cast<uint64>(data2[1]) << 8;
    case 1: h ^= static_cast<uint64>(data2[0]);
    h *= m;
  };

  h ^= h >> r;
  h *= m;
  h ^= h >> r;

  return h;
}

// 32-bit hash
uint32 MurmurHash32A(const void* key, int len, uint32 seed) {
  const uint32 m = 0x5bd1e995;
  const int r = 24;

  uint32 h = seed ^ (len * m);

  const uint32* data = (const uint32 *)key;

  while (len >= 4) {
    uint32 k = *(uint32 *)data;

    k *= m;
    k ^= k >> r;
    k *= m;

    h *= m;
    h ^= k;

    data += 1;
    len -= 4;
  }

  // Handle the last few bytes of the input array
 const uint8* data2 = (const uint8*)data;

  switch (len) {
    case 3: h ^= static_cast<uint32>(data2[2]) << 16;
    case 2: h ^= static_cast<uint32>(data2[1]) << 8;
    case 1: h ^= static_cast<uint32>(data2[0]);
            h *= m;
  };

  // Do a few final mixes of the hash to ensure the last few
  // bytes are well-incorporated.

  h ^= h >> 13;
  h *= m;
  h ^= h >> 15;

  return h;
}

/* A Simple Hash Function */
unsigned int simple_hash(char *str)
{
	register unsigned int hash;
	register unsigned char *p;

	for(hash = 0, p = (unsigned char *)str; *p ; p++)
		hash = 31 * hash + *p;

	return (hash & 0x7FFFFFFF);
}

/* RS Hash Function */
unsigned int RS_hash(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 Function */
unsigned int JS_hash(char *str)
{
         unsigned int hash = 1315423911;

         while (*str)
         {
                 hash ^= ((hash << 5) + (*str++) + (hash >> 2));
         }
        
         return (hash & 0x7FFFFFFF);
}

/* P. J. Weinberger Hash Function */
unsigned int PJW_hash(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 Function */
unsigned int ELF_hash(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 Function */
unsigned int BKDR_hash(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);
}

/* SDBM Hash Function */
unsigned int SDBM_hash(char *str)
{
         unsigned int hash = 0;

         while (*str)
         {
                 hash = (*str++) + (hash << 6) + (hash << 16) - hash;
         }

         return (hash & 0x7FFFFFFF);
}

/* DJB Hash Function */
unsigned int DJB_hash(char *str)
{
         unsigned int hash = 5381;

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

         return (hash & 0x7FFFFFFF);
}

/* AP Hash Function */
unsigned int AP_hash(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);
}

/* CRC Hash Function */
unsigned int CRC_hash(char *str)
{
    unsigned int        nleft   = strlen(str);
    unsigned long long  sum     = 0;
    unsigned short int *w       = (unsigned short int *)str;
    unsigned short int  answer  = 0;

    /*
     * Our algorithm is simple, using a 32 bit accumulator (sum), we add
     * sequential 16 bit words to it, and at the end, fold back all the
     * carry bits from the top 16 bits into the lower 16 bits.
     */
    while ( nleft > 1 ) {
        sum += *w++;
        nleft -= 2;
    }
    /*
     * mop up an odd byte, if necessary
     */
    if ( 1 == nleft ) {
        *( unsigned char * )( &answer ) = *( unsigned char * )w ;
        sum += answer;
    }
    /*
     * add back carry outs from top 16 bits to low 16 bits
     * add hi 16 to low 16
     */
    sum = ( sum >> 16 ) + ( sum & 0xFFFF );
    /* add carry */
    sum += ( sum >> 16 );
    /* truncate to 16 bits */
    answer = ~sum;

    return (answer & 0xFFFFFFFF);
}


std::string Itoa(int value) {
  if (value < 0) {
    value *= -1;
  }
  char character[] = "0123456789abcdefghijklmnopqrstuvwxyz";
  std::string res = "";
  do {
    res += character[value % sizeof(character)];
  } while ((value /= sizeof(character)) > 0);
  return res;
}
int GetTime() {
  timeval tv;
  gettimeofday(&tv, NULL);
  return tv.tv_sec * 1000000 + tv.tv_usec;
}
class StringHash {
 public:
  uint64 operator()(const std::string& s) const {
    return CityHash64(s.c_str(), s.size());
    // return MurmurHash64A(s.c_str(), s.size(), kFingerPrintSeed) % (unsigned int) 0xFFFFFFFF;
  }
};
class StringEqual {
 public:
  bool operator()(const std::string& left, const std::string& right) const {
    return left == right;
  }
};
int main(int argc, char** argv) {
  const int kDataSize = 1000000;
  std::string content = "";
  std::vector<std::string> data;
  for (int i = 0; i < kDataSize; ++i) {
    content = "";
    for (int j = 0; j < 10; ++j) {
      content += Itoa(rand());
    }
    data.push_back(content);
  }
  //murmur test

  int start = GetTime();
  for (int i = 0; i < kDataSize; ++i) {
    MurmurHash64A(data[i].c_str(), data[i].size(), kFingerPrintSeed);
  }
  printf("murmur64: %d\n", GetTime() - start);  
  
  start = GetTime();
  for (int i = 0; i < kDataSize; ++i) {
    MurmurHash32A(data[i].c_str(), data[i].size(), kFingerPrintSeed);   
  }
  printf("murmur32:%d\n", GetTime() - start);  
  //simple hash
  start = GetTime();
  for (int i = 0; i < kDataSize; ++i) {
    simple_hash(const_cast<char*>(data[i].c_str()));
  }
  printf("simple hash:%d\n", GetTime() - start);  
  // bkdr hash
  start = GetTime();
  for (int i = 0; i < kDataSize; ++i) {
    BKDR_hash(const_cast<char*>(data[i].c_str()));
  }
  printf("bkdr hash:%d\n", GetTime() - start);  

  // AP  hash
  start = GetTime();
  for (int i = 0; i < kDataSize; ++i) {
    AP_hash(const_cast<char*>(data[i].c_str()));
  }
  printf("AP hash:%d\n", GetTime() - start);  

  // City  hash
  start = GetTime();
  for (int i = 0; i < kDataSize; ++i) {
    CityHash64(data[i].c_str(), data[i].size());
  }
  printf("city hash:%d\n", GetTime() - start);  
    std::tr1::unordered_map<std::string, int, StringHash, StringEqual> my_map_city;
  // City  hash insert
  start = GetTime();  
  for (int i = 0; i < kDataSize; ++i) {
    my_map_city[data[i]] = i;
  }
  printf("city hash insert:%d\n", GetTime() - start);  
  
  // map insert
  std::map<std::string, int> my_map_tree;
  start = GetTime();  
  for (int i = 0; i < kDataSize; ++i) {
    my_map_tree[data[i]] = i;
  }
  printf("tree map insert:%d\n", GetTime() - start);  
  
  // City  hash search
  start = GetTime();
  int value = 0;
  for (int i = 0; i < kDataSize; ++i) {
    value = my_map_city[data[i]];
  }
  printf("city hash search:%d\n", GetTime() - start);  

  // map search
  start = GetTime();  
  for (int i = 0; i < kDataSize; ++i) {
    value = my_map_tree[data[i]];
  }
  printf("tree map search:%d\n", GetTime() - start);  

  
  
}


参考文献

[1]http://blog.youkuaiyun.com/liuben/article/details/5050697

[2]http://www.cnblogs.com/atlantis13579/archive/2010/02/06/1664792.html

[3]http://sites.google.com/site/murmurhash/ 

[4]http://blog.youkuaiyun.com/wisage/article/details/7104866

[5]http://code.google.com/p/cityhash/

[6]http://gcc.gnu.org/onlinedocs/libstdc++/ext/pb_ds/index.html

[7]http://en.wikipedia.org/wiki/Hash_table

[8]http://en.wikipedia.org/wiki/MurmurHash

[9]http://hi.baidu.com/fdwm_lx/blog/item/f670e73582c8411d90ef3950.html

[10]http://www.cnblogs.com/Frandy/archive/2011/07/26/Hash_map_Unordered_map.html

密码学 hash算法实验代码及报告
12-03
利用libtomcrypt库进行sha1、sha512等的值计算
Hash知识点总结
12-23
Hash相关知识点 面试基本提纲  1. hash 表是什么 2. hash 表用来做什么 3. hash 表是怎么做到可以搜索的？ 1. hash 值如何求，hashCode 是什么，用来做什么 2. 冲突 1. 什么是冲突 2. 怎么避免冲突 3. 冲突了...
关于hash相关的总结
qq_30525851的博客
12-16 193
1.hashmap为什么线程不安全？    1.1 size没有用volatile修饰，如果多线程同时进行put和remove，size的值不准    1.2 如果多线程同时put一个key值相同，会导致其中一个线程的value值丢失    1.3 如果多线程正好发送在resize的时候，也会导致数据的丢失 相关文章参考：    https://www.cnblogs.com/First...
Hash总结
weixin_55851276的博客
04-12 257
Hash
关于字符串hash函数的总结
日新为道的专栏
11-22 619
占位，待补充！
Hash相关总结
xym222的博客
08-13 442
参考博客：【1】hash冲突解决方法 【2】hashCode()函数与equals的作用与区别 Hash冲突 处理方法： （1）开放定址法（线性探测再散列，二次探测再散列，随机探测再散列） （2）链地址法：将产生冲突的对象链接再同一链表中。（hashmap处理冲突的方法） （3）再哈希法：重复计算hash，直到不发生冲突为止。 （3）建立公共溢出区：将所有的冲突数据存在这个地方，不存在表中。 简述 把任意长度的输入，通过Hash算法变成固定长度的输出，几位Hash值。由于哈希值空间远小于输入空间，故可能发生
Redis的五大数据类型之哈希(Hash)的总结
01-07
Hash的常用操作命令总结 图片来源：https://www.runoob.com/redis/redis-hashes.html 部分命令使用实例 1.HSET、HGET 、HMSET、 HMGET HSET key field value 将哈希表 key 中的字段 field 的值设为 value...
Java常用HASH算法总结【经典实例】
08-29
总结，Java中常见的哈希算法有多种，每种都有其特定的优缺点。在实际应用中，开发者需要根据需求和场景选择合适的哈希算法。例如，对于小规模数据，简单的加法或旋转哈希可能就足够了；而对于大数据集，可能需要更...
Redis String 类型和 Hash 类型学习笔记与总结
09-10
Redis String 类型和 Hash 类型是 Redis 数据库中两种基本的数据结构，它们各自有着独特的特性和应用场景。在本篇学习笔记中，我们将深入探讨这两种类型，了解它们的功能、操作方法以及如何在实际应用中有效利用。 ...
HASH函数实验指导
06-06
Hash函数及数字签名应用实验 验证码的实现过程
Murmurhash 哈希算法 介绍与实现
qigaohua的博客
10-31 2万+
最近在项目代码中看到了一种hash算法，以前没有遇见过，在此记录下来。   一、介绍   MurmurHash 是一种非加密型哈希函数，适用于一般的哈希检索操作。 由Austin Appleby在2008年发明， 并出现了多个变种，都已经发布到了公有领域(public domain)。与其它流行的哈希函数相比，对于规律性较强的key，MurmurHash的随机分布特征表现更良好。—摘自w...
电商系统学习笔记之重要的hash算法MurmurHash
Just Do It!
05-02 4363
先看看string的默认hash方法，代码如下 /** * Returns a hash code for this string. The hash code for a * {@code String} object is computed as * &lt;blockquote&gt;&lt;pre&gt; * s[0]*31^(n-1) + s[1...
MurmurHash PK CityHash
热门推荐
yfk的专栏
03-14 2万+
1. 概述 murmurhash是 Austin Appleby于2008年创立的一种非加密hash算法，适用于基于hash进行查找的场景。murmurhash最新版本是MurMurHash3，支持32位、64位及128位值的产生。 murmurhash标准使用c++实现，但是也有其他主流语言的支持版本，包括：perl、c#、ruby、python、java等。murmurhash在多个开源项
[buuctf.reverse] 126-130
weixin_52640415的博客
06-26 863
126_[NPUCTF2020]EzObfus-Chapter2 128_[GKCTF 2021]app-debug 129_[FlareOn2]YUSoMeta 130_[GXYCTF2019]minecraft
字符串哈希算法——BKDRHash
机器学习
09-01 5225
BYVoid对常用的几种字符串哈希函数进行了一次小小的评测。其评测结果，按照得分从高到低依次为BKDRHash，APHash，DJBHash，JSHash，RSHash，SDBMHash，PJWHash，ELFHash。其中，最优的字符串哈希算法BKDRHash函数实现如下： // BKDR Hash Function unsigned int BKDRHash(char *str) { ...
C++_Hash容器总结
惊鸿一博
07-15 1616
一、Hash基本概念 散列Hash函数是一种特殊的映射函数, 散列表Hash Table由散列函数所产生的一种数据结构. 这是一种非常重要的数据结构. 首先, 先了解散列表在数据结构方面的基础: 散列表是用于存储动态集的一种非常有效的数据结构。通过散列函数h(key)的计算结果，直接得到key关键字表示的元素的存储地址。散列技术中，可能会有两个不同的key1和key2，通过h(key)计算得到的地址是一样的，这就发生了冲突。散列技术中散列函数h(key)和解决冲突的技术是最关键的问题。 1.1 散列
一致性hash算法 java代码实现与测试
三分钟冷血的专栏
05-24 5558
写了一个一致性hash的java代码，算法是用别人的， 然后自己做了一个测试，用线程池起了1000个线程， 每个线程hash10000次，模拟一万次数据hash，并将结果上传。 /** * 一致性hash代码 * * @author shiguiming * * @param */ public class Shared { // 真实节点对应的虚拟节点数量 priva
一致性哈希算法的Java实现
曾文锋开发日志
08-15 389
一致性哈希算法的Java实现   关于一致性哈希算法的原理，网上有很多介绍，在此只是简单介绍一下，不做详细说明。   一致性哈希算法是分布式系统中常用的算法，比如有N台缓存服务器，你需要将数据缓存到这N台服务器上。一致性哈希算法可以将数据尽可能平均的存储到N台缓存服务器上，提高系统的负载均衡，并且当有缓存服务器加入或退出集群时，尽可能少的影响现有缓存服务器的命中率，减少数据对后台服务的...
Java实现的各种Hash算法总结
"该资源是关于Hash算法的集合，特别提到了FNV1算法作为推荐使用的算法。包含多个不同的Hash算法实现，如Additive Hash、Rotating Hash和One-by-One Hash等。" 在信息技术领域，Hash算法（哈希算法）是一种将任意...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值