两组的有效交集

Question

我有两个集合（或地图），需要有效处理它们的交集。 我知道有两种方法可以做到这一点：

• 像 std::set_intersection 一样遍历两个映射：O(n1+n2)
• 遍历一张地图并在另一张地图中查找元素：O(n1*log(n2))

根据大小，这两个解决方案中的任何一个都明显更好（已计时），因此我需要根据大小在这些算法之间切换（这有点混乱） - 或者找到一个优于两者的解决方案，例如使用 map.find() 的一些变体，将前一个迭代器作为提示（类似于 map.emplace_hint(...)） - 但我找不到这样的函数。

问题：是否可以直接使用 STL 或某些兼容库来结合两种解决方案的性能特征？

请注意，性能要求使这与之前的问题有所不同，例如 Efficient intersection of sets?

Answer 1

几乎在所有情况下std::set_intersection 都是最佳选择。 仅当集合包含非常少量的元素时，另一种解决方案可能会更好。 由于原木的性质以二为底。 比例为：

n = 2，log(n)= 1
n = 4，log(n)= 2
n = 8，log(n)= 3
.....
n = 1024 log(n) = 10

如果集合的长度超过 5-10 个元素，则 O(n1*log(n2) 比 O(n1 + n2) 复杂得多。

这样的功能被添加到 STL 中是有原因的，并且它是这样实现的。它还将使代码更具可读性。

对于长度小于 20 的集合，选择排序比合并或快速排序更快，但很少使用。

Answer 2

对于实现为二叉树的集合，实际上有一种算法，它结合了您提到的两个过程的优点。本质上，您可以像 std::set_intersection 那样进行合并，但是在一棵树中迭代时，您会跳过所有小于另一棵树中当前值的所有分支。

生成的交集需要 O(min(n1 log n2, n2 log n1, n1 + n2)，这正是您想要的。

不幸的是，我很确定 std::set 不提供可以支持此操作的接口。

我过去做过几次，在加入倒排索引和类似的事情时。通常我会使用 skipTo(x) 操作来制作迭代器，该操作将前进到下一个元素 >= x。为了满足我承诺的复杂性，它必须能够在 log(N) 摊销时间内跳过 N 个元素。然后一个交叉点是这样的：

void get_intersection(vector<T> *dest, const set<T> set1, const set<T> set2)
{
    auto end1 = set1.end();
    auto end2 = set2.end();
    auto it1 = set1.begin();
    if (it1 == end1)
        return;
    auto it2 = set2.begin();
    if (it2 == end2)
        return;
    for (;;)
    {
        it1.skipTo(*it2);
        if (it1 == end1)
            break;
        if (*it1 == *it2)
        {
            dest->push_back(*it1);
            ++it1;
        }
        it2.skipTo(*it1);
        if (it2 == end2)
            break;
        if (*it2 == *it1)
        {
            dest->push_back(*it2);
            ++it2;
        }
    }
}

它可以使用迭代器向量轻松扩展到任意数量的集合，并且几乎任何有序集合都可以扩展以提供所需的迭代器——排序数组、二叉树、b-树、跳过列表等。

Answer 3

我不知道如何使用标准库来做到这一点，但如果你编写了自己的平衡二叉搜索树，这里是如何实现有限的“带提示查找”。 （根据您的其他要求，BST 重新实现也可以省略父指针，这可能会在性能上胜过 STL。）

假设提示值小于要找到的值，并且我们知道提示节点所属的左子树的提示节点的祖先堆栈。首先在提示节点的右子树中正常搜索，根据需要将节点推入堆栈（为下次提示准备）。如果这不起作用，则当堆栈顶部节点的值小于查询值时，弹出堆栈。从弹出的最后一个节点开始搜索（如果有），根据需要推送。

我声称，当使用这种机制以升序连续搜索值时，（1）每个树的边缘最多遍历一次，并且（2）每个查找最多遍历两个下降路径的边缘。给定具有 n2 个节点的二叉树中的 2*n1 条下降路径，边的成本为 O(n1 log n2)。也是 O(n2)，因为每条边都遍历一次。

Answer 4

关于性能要求，O(n1 + n2) 在大多数情况下是一个非常好的复杂度，因此只有在紧密循环中进行此计算时才值得考虑。

如果你真的需要它，组合方法也不错，也许是这样的？

伪代码：

x' = set_with_min_length([x, y])
y' = set_with_max_length([x, y])
if (x'.length * log(y'.length)) <= (x'.length + y'.length):
     return iterate_over_map_find_elements_in_other(y', x')

return std::set_intersection(x, y)

我认为您不会找到一种算法能够克服这些复杂性中的任何一个，但很高兴被证明是错误的。