整数哈希

整数哈希介绍

为什么要整数哈希

很多时候，可以直接用整数作为键，比如QQ号码，手机号码，但这些号码的分布性不是均匀的（比如高位的变化更少，低位变化更多)。
分布均匀指的是每位为0或1的概率都是一样的。

理论基础

整数哈希的目标

1. 函数要是可逆的（1对1的映射)
2. 雪崩效应（输入中1bit的变化影响输出中1/4 到 1/2的bits变化)

可逆操作

    key + const_value 加法是可逆
    key - const_value 减法是可逆
    key ^ const_value 异或是可逆的
    ~key 取反也是可逆的
    key * const_value 乘以一个奇数也是可逆的

复杂操作的可逆性分析

    a = (a+0xfd7046c5) + (a<<3); // <<和+ 是可逆
    a = (a+0xfd7046c5) + (a>>3); // >>和+ 不保证是可逆的
    a = (a^0xb55a4f09) ^ (a<<16); // ^ 和<< 是可逆
    a = (a^0xb55a4f09) ^ (a>>16); // ^ 和>> 是可逆

雪崩操作

+ bit is 1 导致左边临近的所有1和最后一个0被反转( 0111 + 1 = 1000)
- bit is 1 导致左边临近的所有0和最后一个1被反转( 1000 - 1 = 0111)
所以加法和减法可以从低向高扩散变化

~ 可以把过多的0变1，把过多的1变成零，最后结合原始值，就可以保持0和1的平衡，以便 +或-可以有效扩散变化。

<< 让低位转到高位。
>> 让高位转到低位。

^ 会把某些位反转，异或可以把两个变量的变化组合一起来，这经常跟移位一起来实现1个bit的变化扩散到2个bit上。

乘法的本质是多个<< 和 +，也可以引起雪崩。除法也可以影响雪崩（特别是素数)。
不用乘法和除法的原因的是，整数的乘法和除法太耗CPU了，整数除法是最慢的操作，比浮点数数除法还慢，在一些RISC机器上可能是上百倍的差距。

具体哈希算法介绍

乘法

《计算机编程艺术》中讲过：乘以一个黄金分割数：2654435761(2^32) 可以得到 HASH.
hash = key*2654435761;

乘法的问题在于，低位可以影响高位，但高位不能影响低位。分布是不均匀的。

但不是说乘法hash就没有用，在大量脚本语言中，对象的hash是通过对象的地址值来算hash的（因为对象本身会变化），
对象分配的特点决定了，地址的高位是不变化或变化极少。

uint32 address_hash(char* addr)
{
register uint32 key;
key = (uint32) addr;
return (key >> 3) * 2654435761; //这个3是对齐边界为8
}

这时候MASK, 应该选择高位更好（0xFFFF0000)

除法

hash = key%prime

除法的问题在于，除数需要是素数，而且整数除法比较耗时。

如果除数不是素数，就要求hash值是均匀分布。

    其实除法hash多是用在哈希表中求桶的位置，如果不能保证键的哈希函数是均匀的，那么建议使用素数来取模。

    如果可以保证键值的哈希函数的质量，那么使用 MASK( &MASK)操作取代取模，效率会更高。

其它位运算

Tomas Wang

uint32_t hash32shift(uint32_t key)
{
key = ~key + (key << 15); // key = (key << 15) - key - 1;
key = key ^ (key >> 12);
key = key + (key << 2);
key = key ^ (key >> 4);
key = key * 2057; // key = (key + (key << 3)) + (key << 11);
key = key ^ (key >> 16);
return key;
}

Bob Jenkins' 32 bit integer hash function

uint32_t hash( uint32_t a)
{
   a = (a+0x7ed55d16) + (a<<12);
   a = (a^0xc761c23c) ^ (a>>19);
   a = (a+0x165667b1) + (a<<5);
   a = (a+0xd3a2646c) ^ (a<<9);
   a =(a+0xfd7046c5) + (a<<3); // <<和 +的组合是可逆的
   a = (a^0xb55a4f09) ^ (a>>16);
   return a;
}

这六个数是随机数，通过设置合理的6个数，你可以找到对应的perfect hash.

64 bit Mix Functions

uint64_t hash64shift(uint64_t key)
{
key = (~key) + (key << 21); // key = (key << 21) - key - 1;
key = key ^ (key >> 24);
key = (key + (key << 3)) + (key << 8); // key * 265
key = key ^ (key >> 14);
key = (key + (key << 2)) + (key << 4); // key * 21
key = key ^ (key >> 28);
key = key + (key << 31);
return key;
}

64 bit to 32 bit Mix Functions

uint32_t hash64_32shift(uint64_t key)
{
key = (~key) + (key << 18); // key = (key << 18) - key - 1;
key = key ^ (key >> 31);
key = key * 21; // key = (key + (key << 2)) + (key << 4);
key = key ^ (key >> 11);
key = key + (key << 6);
key = key ^ (key >> 22);
return (int) key;
}

Bob Jenkins' 96 bit Mix Function

uint32_t mix(uint32_t a, uint32_t b, uint32_t c)
{
a=a-b; a=a-c; a=a^(c >> 13);
b=b-c; b=b-a; b=b^(a << 8);
c=c-a; c=c-b; c=c^(b >> 13);
a=a-b; a=a-c; a=a^(c >> 12);
b=b-c; b=b-a; b=b^(a << 16);
c=c-a; c=c-b; c=c^(b >> 5);
a=a-b; a=a-c; a=a^(c >> 3);
b=b-c; b=b-a; b=b^(a << 10);
c=c-a; c=c-b; c=c^(b >> 15);
return c;
}