自定义散列算法

Question

出于无聊，我决定用 python 编写一个散列算法。一切正常，但是我有几个问题：

1. 结果相似（例如hash(1234)与hash(4321)有一个字符差异）

2. 有一个重复的序列形成（在较小的输入上更明显）

我使用的大多数值都是随机的，我没有编写哈希算法的经验，但我想试一试。有什么办法可以解决我遇到的 2 个问题吗？

def mash(n):
    l = [int(x) for x in list(str(n))]
    m = []
    for i in range(len(l)):
        if pow(len(l) >> 1, (i + 1) << 3) % (i + 1) == 0 and i != 0:
            m[-1] = int(str(m[-1]) + str(l[i]))
        else:
            m.append(l[i])
    return m

def hash(content, key=None):
    """Hashes the content (either a string or number"""
    o = [0] * 128
    if type(content) is float:
        while content % 1 != 0:
            content = content * 10
        content = int(content)
    if type(content) is str:
        content = int(''.join([str(ord(x)) for x in list(content)]))
    if type(content) is int:
        content = mash(content)
        _ = []
        for i in range(len(content)):
            _.append((chr(((content[i] * (i << 3)) % 94) + 33)))
            # 33 - 126
        content = ''.join(_)
    elif type(content) is not str:
        raise Exception
    z = [ord(x) for x in list(content)]
    for i in range(len(z)):
        if z[i] % 2 == 0:
            n = next((i for i, x in enumerate(o) if not x and i % 2 == 0), 0)
        else:
            n = next((i for i, x in enumerate(o) if not x and i % 2 == 1), 0)
        o[n] = content[i]
    o = [str(x) for x in o]
    o.reverse()
    init_n = o.count('0')
    while o.count('0') > 5:
        n = next((i for i, x in enumerate(o) if x == '0'), None)
        o[n] = chr(((pow(init_n >> 1, o.count('0'))) % 94) + 33)
    o.reverse()
    return ''.join(o)

请注意，key 参数尚未实现。希望在尝试其他功能之前解决现有问题。

Answer 1

我知道这个问题现在已经有四年左右了，但我仍然想对这篇 Stack Overflow 帖子给出答案。

回想一下哈希表，我们的目标是“接近”恒定时间搜索数据。我们可以选择使用二叉搜索树来获得更快的 O(log n)，尽管它必须按排序顺序存储并保持平衡。

我们可以做得更好，通过使用内存来权衡速度！这是我们在计算机科学中看到的常见模式。

创建散列函数以将各种大小的数据转换为可以用键标识的固定“地址”。关键特性包括该算法必须快速完成、与现有密钥的冲突最小以及可重复。碰撞会发生，所以我们需要一个策略来处理它们。

class BasicHashTable:
    """ Simple HashTable implementation """
    class HashableItem:
        def __init__(self, key=None, value=None):
            self.key = key
            self.value = value

    def __init__(self):
        self.capacity = 4
        self.size = 2**self.capacity - 1
        self.slot = [None for _ in range(self.size)]
        self.count = 0

    def _hash(self, s):
        i = 1
        hash_value = 0
        for char in string:
            h += ord(char) * i
            i += 1
        return h % self.size

这里我有一个散列算法，它基于字符的序数值和字符串中的位置。我还返回该值，因为它被限制在 BasicHashTable 大小约束内。

回想一下，该算法满足前面概述的约束：

• 快速
• 最少的碰撞
• 可重复

我省略了 put 和 get 两个关键接口。因为它们可能会有所不同并且超出了本文的范围。不过，他们将处理冲突并在 BasicHashTable 超出容量时调整其大小。

干杯！