Question

我有一大组整数序列，下面是小样本：

简单地将它们存储为元组列表会给我带来内存错误，因此我正在寻找可以保存它们的更好的数据结构（或等效信息）。序列之间的顺序并不重要（即序列没有id）但需要保留每个序列中的顺序

。

有关如何有效地做到这一点的任何想法？我正在考虑嵌套字典;以上示例将如下所示：

{1: {2: {-1: 1}, 3: {2: {-1: 2}, -1: 0}, -1: 2}, 2: {-1: 1}, 4: {-1: 1}}

“叶子”值（由键-1给出）是各个序列的计数。当然，这并没有利用所有键都是整数的事实。

粗略地说，我希望管理大约10亿个平均长度为3的序列，并且具有大量冗余。不同整数的数量约为一百万。有什么好主意/现有的图书馆吗？

编辑：

构建数据结构的“子集”应该是有效的，如下所示。给定整数x，只获取包含x的序列。例如，如果x=2，那么我们将从初始数据结构构建以下子集：

{1: {2: {-1: 1}, 3: {2: {-1: 2}, -1: 0}, -1: 0}, 2: {-1: 1}}

如果可能，我还希望能够按如下方式构建子集。我指定了一对整数(x,y)，相应的子集是x和y都出现的序列集，第一个x出现在第一个y之前1}}。例如，对于(x,y)=(1,2)我们会得到

{1: {2: {-1: 1}, 3: {2: {-1: 2}, -1: 0}, -1: 0}}

我没有明确的O（log n）要求，最后它应该尽可能快地运行:)不幸的是我无法提供实际的数据样本，因为它不是我的共享。

Answer 1

考虑到冗余量，您可以使用Trie获得良好的压缩，这会折叠所有常见前缀。

看起来你的目标是使用嵌套字典结构，但是哈希映射不一定是最节省空间的存储（你没有提到对查找性能的任何要求）。

例如，考虑将其存储为嵌套列表，使用1元组来区分叶值（尽管我们可能会提供更清洁的东西）：

trie = [ [1, (2,),
             [2, (1,)],
             [3, [2, (2,)]],
         [2, (1,)],
         [4, (1,)]
       ]

平均长度为3，这应该非常浅，希望每个级别使用列表而不是字典的时间更少。

请注意，如果某些分支很长而且裸露，则可以以代码复杂性为代价压缩冗余深度。考虑子树

[1, [2, [3, ... [n, (1,)]...]]]

可以编码为

[1, 2, 3, ..., n, (1,)]

只要你区分扁平序列和兄弟姐妹（这里， leaf 总是1元组，子树总是一个列表，其他任何东西都是平坦序列中的下一个元素。）

新的子集要求更复杂。我可以想到一些可能的方法：

天真/暴力搜索：再次依赖于您的访问模式，您可以返回生成器而不是匹配子树的急切全深度副本（子尝试）
在每个子树的顶部存储一个bloom过滤器，指示其中的值。您的搜索与（1）的工作方式相同，但您可以快速跳过无法匹配的子树。
- 每个级别的过滤器只是其子级中过滤器的逻辑或
如果您需要快速查找，可以进行反向查找。例如，这可能是包含密钥的每个序列的集合（因此您有一百万个密钥）。在获取包含 x 的序列和包含 y 的序列的并集后，您需要迭代结果以查看哪个具有 x 和 y 的顺序正确。

此方案的难点在于表示每个序列。您需要链接到Trie中的叶节点（并且能够以某种方式从叶到根迭代），或者您需要单独的每个序列的平面副本，这看起来很浪费

Answer 2

对于像平均3个整数那样的短序列，我看不到比将它们编码为具有引用计数的数组更有效的效果;

[
 (2, [1]),
 (1, [2]),
 (1, [1, 2]),
 (2, [1, 3, 2]),
 (1, [4])
]

考虑一下;根据建议使用Trie，对于每个新的子序列，您至少需要一个新数组和一个元组，这意味着100M数组和元组，就像这个版本一样。数组存储也有一个100M数组/元组的最大，而如果子序列偏离多个数字，则Trie不会。 Trie闪耀着更长的序列，其中消除了大量的重复，但是投入额外的数组以平均保存＆lt; 2整数并不足以带来明显的优势。

您甚至可以通过将refcount添加为数组中的第一个元素来删除元组，并节省更多内存。作为次要的好处，你能看到迭代序列比迭代数组更简单的方法吗？

对于空间优化数组，您可以查看array module。

在python中有效地存储一组整数序列

2 个答案: