Question

我正在开发一个python应用程序，它的核心是执行以下任务：

在内部，有一个项目列表，比如A。浏览另一个项目列表，例如B，以及列表b中的每个项B，在a中找到相应的项A。应该总是有这样一个项目 - 如果没有匹配，程序将失败。

当然，这似乎是哈希排序数据结构中二进制搜索的完美应用示例。

问题是列表中的项目是复杂的对象。现在，假设每个条目a或b本身就是一个包含这种形状的大约10个向量（有时更多，有时更少）的列表：

vector = [ id, status, px, py, pz ]

其中id和status是整数值，px，py和pz是浮点值，因此项目可能如下所示：

aExample = [ [   2, -1,  0.5,  0.7,  0.9 ], 
             [  -1, -1, -0.4, -0.6, -0.8 ],
             [  25,  2,  1.1,  1.3, -1.7 ],
             [  24,  2,  1.2,  1.1,  1.6 ],
             [ -24,  2,  0.9,  0.8,  2.1 ],
             [  11,  1,  1.2,  1.3,  2.6 ],
             [ -11,  1,  1.4,  1.2,  2.4 ],
             [  13,  1,  1.8,  1.6,  2.1 ],
             [ -11,  1,  3.2,  0.1,  3.6 ] ]

列表A存储了数十万个这样的条目，列表B存储了几万个。

要添加更多复杂功能，

匹配要求向量的数量相同，但不是它们的排序
匹配要求所有id和status值匹配
匹配不需要完全同意浮点值px，py，pz，但需要在某些permille级别容差内达成近似一致才能保持唯一。< / LI>

现在，正如您可能想象的那样，我很难想出一个高效且可维护的数据结构。

在这一点上唯一可行的方法在我看来，我应该尝试首先将我的数据分类为需要硬匹配的值，然后执行标准搜索＆＃34;最佳软匹配＆＃34;在每个类别中。但我很好奇：是否有任何散列算法支持这种混合方法，要求数据的某些部分完全匹配，而其他部分只是为了产生类似的散列？或者你有任何其他建议如何有效地解决这个问题？

Answer 1

我会通过以下方式接近它：

定义一个类变量 id ，状态， px ， py ， pz < / strong>名为矢量

向量类还必须使用公式定义 hash（）和等于方法：

def eq(self, other): self.id == other.id and self.status == other.status and bucketOf(self.px,self.py,self.pz) == bucketOf(other.px, other.py, oyther.pz)

def hash(): hash(id + status + bucketOf(px + py + pz) )

请注意哈希是一些具有低哈希冲突的哈希函数， + 不是数学上的加法，而只是一个指标，包括在内哈希计算， bucketOf 计算 px ， py 和 p 范围内的唯一编号/ ID你认为你的公差范围内足够接近

由于哈希不能保证零冲突，因此您需要从哈希到具有相同哈希值的矢量列表的字典映射。

然后，为了找到 Vector 的给定实例的匹配实例，您计算其哈希并使用相同哈希的向量列表您为“等于”返回true的元素过滤它的值。

这样，实例的平等和快速检索的标准完全取决于 Vector 类定义的 hash 和 eq 。

它是如何在Java中为HashMap做的。

请参阅this answer更详细地解释数据结构以及强加于哈希和 eq 的合同。

我的免责声明是我主要是Java开发人员，所以这里的某些建议可能不容易转移到Python

在列表中查找近似匹配：在python中散列复杂对象

1 个答案: