高效列表交集算法

给定两个列表（不一定排序），找到这些列表的交集的最有效的非递归算法是什么？

您可以将第一个列表的所有元素放入哈希集中。然后，迭代第二个，并针对其每个元素，检查哈希以查看其是否存在于第一个列表中。如果是这样，请将其输出为相交的元素。

您可能想看看Bloom过滤器。它们是位向量，可为元素是否为集合的成员提供概率性答案。集合交集可以通过简单的按位与运算来实现。如果您有大量的空交集，则布隆过滤器可以帮助您快速消除这些交集。但是，您仍然必须借助此处提到的其他算法之一来计算实际的交点。 http://en.wikipedia.org/wiki/Bloom_filter

不带哈希，我想您有两个选择：

• 天真的方法是将每个元素与每个其他元素进行比较。O（n ^ 2）
• 另一种方法是先对列表进行排序，然后遍历它们：O（n lg n）* 2 + 2 * O（n）

从eviews功能列表中，它似乎支持复杂的合并和连接（如果按照数据库术语中的“ join”，它将计算交集）。现在浏览您的文档:-)

此外，eviews拥有自己的用户论坛-为什么不在那里询问_

使用set 1构建一个二叉搜索树，O(log n)并使用set2进行迭代并搜索BST m X O(log n)总数O(log n) + O(m)+O(log n) ==> O(log n)(m+1)

在C ++中，可以使用STL映射尝试以下方法

vector<int> set_intersection(vector<int> s1, vector<int> s2){

    vector<int> ret;
    map<int, bool> store;
    for(int i=0; i < s1.size(); i++){

        store[s1[i]] = true;
    }
    for(int i=0; i < s2.size(); i++){

        if(store[s2[i]] == true) ret.push_back(s2[i]);

    }
    return ret;
}

这是我想出的另一种可能的解决方案，它在时间复杂度上采用O（nlogn），而没有任何额外的存储。您可以在这里查看https://gist.github.com/4455373

它是这样工作的：假设这些集合不包含任何重复，请将所有集合合并为一个并对它进行排序。然后循环遍历合并的集合，并在每次迭代中在当前索引i和i + n之间创建一个子集，其中n是Universe中可用集合的数量。我们在循环时寻找的是一个大小为n的重复序列，该序列等于宇宙中集合的数量。

如果i处的那个子集等于n处的那个子集，这意味着i处的元素重复了n次，这等于集合的总数。并且由于任何集合中都没有重复，这意味着每个集合都包含该值，因此我们将其添加到交集。然后我们将索引移动i + i和n之间剩余的值，因为这些索引中肯定没有一个会形成重复序列。

首先，使用quicksort对两个列表进行排序：O（n * log（n）。然后，通过首先浏览最低值并添加公共值来比较列表，例如，在lua中）：

function findIntersection(l1, l2)
    i, j = 1,1
    intersect = {}

    while i < #l1 and j < #l2 do
        if l1[i] == l2[i] then
            i, j = i + 1, j + 1
            table.insert(intersect, l1[i])
        else if l1[i] > l2[j] then
            l1, l2 = l2, l1
            i, j = j, i
        else
            i = i + 1
        end
    end

    return intersect
end

这是列表的O(max(n, m))位置n和m大小。

编辑：快速排序是递归的，如评论中所述，但似乎有非递归 实现

使用跳过指针和SSE指令可以提高列表交集效率。

为什么不实现自己的简单哈希表或哈希集？如果您的列表很大，那么避免nlogn交叉是值得的。

由于您已经对数据有所了解，因此您应该能够选择一个好的哈希函数。

我赞成“设置”的想法。在JavaScript中，您可以使用第一个列表来填充对象，并将列表元素用作名称。然后，使用第二个列表中的列表元素，查看这些属性是否存在。

如果有内置的对集的支持（您在标题中称呼它们），通常会有一个交集方法。

无论如何，就像有人说的那样，如果您对列表进行了排序，那么您可以轻松地做到这一点（我不会张贴代码，有人已经这样做了）。如果您不能使用递归就没有问题。有快速排序的无递归实现。

我得到了一些很好的答案，从这个，你可能能够应用。我还没有机会尝试它们，但是由于它们也涵盖了交叉路口，因此您可能会发现它们很有用。

在PHP中，类似

function intersect($X) { // X is an array of arrays; returns intersection of all the arrays
  $counts = Array(); $result = Array();
  foreach ($X AS $x) {
    foreach ($x AS $y) { $counts[$y]++; }
  }
  foreach ($counts AS $x => $count) {
    if ($count == count($X)) { $result[] = $x; }
  }
  return $result;
}

根据Big-Oh符号的定义：

如果存在正常数c和n 0，则T（N）= O（f（N）），使得当N≥n 0时T（N）≤cf（N）。

在实践中，这意味着如果两个列表的大小相对较小，则在两个for循环中少写100个元素就可以了。循环第一个列表，然后在第二个列表中查找相似的对象。就我而言，它工作得很好，因为列表中的最大元素数不会超过10-20。但是，一个好的解决方案是对第一个O（n log n）进行排序，对第二个O（n log n）进行排序，然后将它们合并，另一个O（n log n）大致得出O（3 n log n），说这两个列表的大小相同。