在大字典中查找单词的存在

Question

假设我有一个包含 2 亿字的平面文件的大型字典，而我的函数需要检查字典中是否存在任何给定的字，那么最快的方法是什么？您无法将字典存储在内存中，因为您只有 1GB 的内存。您可以将它存储在数据库中，但是如果没有任何优化，查询它仍然会非常非常慢。您无法索引完整的单词，因为您没有足够的资源。

编辑：除了下面提到的文件优化方法外，还有没有数据库优化？我正在考虑创建部分索引，例如对于单词中的每 2 个字母，我创建一个索引。这会加快数据库查询吗？

Answer 1

这是Bloom filter 的经典用例。布隆过滤器是一种概率数据结构，它针对成员资格测试进行了优化（“X 是这个集合的成员吗？”），并提供 O(1) 查找。作为交换，你引入了一个任意小的误报概率——也就是说，过滤器会说一个特定的词存在，但实际上并不存在。您使用的内存越多，您可以使这个概率越小。但是，漏报的概率为零：如果一个词确实存在，过滤器永远不会说它不存在。

在您的特定情况下，使用 80 亿位 (1 GB) 时，每 1,000,000,000 次试验中的误报率可能略高于 1。这是一个极低的误报率。如果您查找 2 亿个随机字符串，您永远不会遇到一个误报的概率约为 82%。

这不需要对字典进行排序，空间效率很高，并且不需要数据库或其他辅助存储结构。总的来说，它可能是满足您需求的不错选择。

Answer 2

使用Trie 可以有效地解决经典的单词查找问题。不幸的是，正如您所提到的，您无法将所有您需要的数据存储在内存中，但这不应该阻止您使用 Trie 来减少搜索空间。假设您只存储初始段，而不是将整个单词集存储在 Trie 中，并且您的末端节点指向可以在数据库中轻松（且快速）搜索的小型数据集合。

Answer 3

二分查找

假设字典中的单词按字母顺序排列，我会尝试修改binary search。通过跳转到文件的中点位置并查看其中的单词来划分和征服文件。如果猜到高，则将较低的分成两半，然后重试，直到没有文件位置可供尝试或找到该单词。

（作为outis mentioned in a comment，在跳转到文件位置后，您需要前后扫描以找到您跳转到的单词的边界。）

您可以通过根据单词的第一个字母立即猜测位置块来优化这一点。例如，如果单词以“c”开头，则从文件的第 3/26 部分开始搜索。但实际上，我认为这个早期的猜测总体上只会产生微不足道的影响。

其他优化可能包括保留索引的一小部分。例如，保留以字母表中每个字母开头的第一个单词的索引，或保留以每个可能的两个字母组合开头的每个单词的索引。这将允许您立即缩小搜索范围。

O(log n)

Answer 4

如果单词有很多前缀和后缀，您可以使用 Directed Acyclic Word Graph 将它们全部加载到内存中（怎么样，DAWG！）

这就像一个 trie，但压缩了共享的后缀。这是否有用取决于您的字典中的内容，但将 200M 装入 1GB 内存可能是可行的。

Answer 5

使用 Boyer–Moore 字符串搜索算法？

http://en.wikipedia.org/wiki/Boyer%E2%80%93Moore_string_search_algorithm

Answer 6

如果您没有索引，请使用流。

有时最简单的解决方案是最好的。

   public Int32 IndexOf(FileStream file, Byte[] ascii_bytes, Int32 start_index)
   {
       Int32 index = -1;
       {
           Int32 current = 0;
           Int64 original_index = 0;
           Boolean found = true;

           file.Position = start_index;
           current = file.ReadByte();
           while (current >= 0)
           {
               if ((Byte)current == ascii_bytes[0])
               {
                   found = true;
                   original_index = file.Position - 1;
                   for (Int32 i = 1; (i < ascii_bytes.Length && current > 0); i++)
                   {
                       current = file.ReadByte();
                       if ((Byte)current != ascii_bytes[i])
                       {
                           file.Position--;
                           found = false;
                           break;
                       }
                   }

                   if (found)
                   {
                       file.Position = original_index;
                       index = (Int32)original_index;
                       break;
                   }
               }
               current = file.ReadByte();
           }
       }
       return index;
   }

Answer 7

假设：

1. 您将在进程的生命周期中多次搜索一个单词（而不是每次查找一个单词时都启动一个进程）。
2. 文件已排序。

您可以部分索引数据，占用大部分可用内存：使用 B 树或排序数组将单词及其起始位置存储在文件中（后者更节省空间，但需要单个连续块; 另外，b-tree 要求您存储块的结束位置，而数组不需要）。留出足够的内存空间以从文件中加载单个单词块。在索引（树遍历或二进制搜索）中搜索将包含该单词的块。从部分索引中找到特定块后，将文件中的相应块加载到内存中并对其执行二进制搜索。

如果你需要额外的内存，你可以从索引中折腾一些元素。使用数组，您可以使用以下伪 C 伪代码将索引减少到 n 个元素：

struct chunk {
    string word;
    int start;
};
chunk index[];
d = index.length / n;
for (i=0;i<n; ++i) {
    index[i] = index[i*d];
}
realloc(index, sizeof(chunk) * n);

由于块 i 的结尾是 index[i+1].start，因此该算法对于数组实现来说非常简单。对于基于 B 树的索引，您可以轻松地将叶子与其父级合并。

Answer 8

如果某些词的查询频率比其他词高得多，那么内存中的 LRU 缓存和其背后的数据库可能是有意义的。