MurmurHash3是否有可能产生一个64位哈希，上面32位都是0

Question

看https://github.com/aappleby/smhasher/blob/master/src/MurmurHash3.cpp我不这么认为，但我想检查一下。

情况是这样的，如果我有一个1,2,3或4字节的键，简单地取这些字节的数值而不是散列到8字节是可靠的吗?或者这些会导致大于4字节的键与murmur3散列的冲突吗?

Answer 1

这种属性对于散列函数来说是一个坏属性。它有效地缩小了函数上域，增加了碰撞的机会，所以看起来不太可能。

此外，这篇博文还提供了MurmurHash的反转函数:

uint64 murmur_hash_64(const void * key, int len, uint64 seed)
{
    const uint64 m = 0xc6a4a7935bd1e995ULL;
    const int r = 47;
    uint64 h = seed ^ (len * m);
    const uint64 * data = (const uint64 *)key;
    const uint64 * end = data + (len / 8);
    while (data != end)
    {
#ifdef PLATFORM_BIG_ENDIAN
        uint64 k = *data++;
        char *p = (char *)&k;
        char c;
        c = p[0]; p[0] = p[7]; p[7] = c;
        c = p[1]; p[1] = p[6]; p[6] = c;
        c = p[2]; p[2] = p[5]; p[5] = c;
        c = p[3]; p[3] = p[4]; p[4] = c;
#else
        uint64 k = *data++;
#endif
        k *= m;
        k ^= k >> r;
        k *= m;
        h ^= k;
        h *= m;
    }
    const unsigned char * data2 = (const unsigned char*)data;
    switch (len & 7)
    {
    case 7: h ^= uint64(data2[6]) << 48;
    case 6: h ^= uint64(data2[5]) << 40;
    case 5: h ^= uint64(data2[4]) << 32;
    case 4: h ^= uint64(data2[3]) << 24;
    case 3: h ^= uint64(data2[2]) << 16;
    case 2: h ^= uint64(data2[1]) << 8;
    case 1: h ^= uint64(data2[0]);
        h *= m;
    };
    h ^= h >> r;
    h *= m;
    h ^= h >> r;
    return h;
}
uint64 murmur_hash_64_inverse(uint64 h, uint64 seed)
{
    const uint64 m = 0xc6a4a7935bd1e995ULL;
    const uint64 minv = 0x5f7a0ea7e59b19bdULL; // Multiplicative inverse of m under % 2^64
    const int r = 47;
    h ^= h >> r;
    h *= minv;
    h ^= h >> r;
    h *= minv;
    uint64 hforward = seed ^ (((uint64)8) * m);
    uint64 k = h ^ hforward;
    k *= minv;
    k ^= k >> r;
    k *= minv;
#ifdef PLATFORM_BIG_ENDIAN
    char *p = (char *)&k;
    char c;
    c = p[0]; p[0] = p[7]; p[7] = c;
    c = p[1]; p[1] = p[6]; p[6] = c;
    c = p[2]; p[2] = p[5]; p[5] = c;
    c = p[3]; p[3] = p[4]; p[4] = c;
#endif
    return k;
}

你可以找到任意多的带有哈希值<2^32的输入。

你关于可靠性的问题没有多大意义:你必须随时准备好正确处理碰撞。根据我的实践，我不建议使用纯整数或指针值作为散列，因为它们可能产生不希望的模式。