2组排序数字的C#最快交集

Question

我在我的应用程序的时间关键部分计算 2 组排序数字的交集。这个计算是整个应用程序最大的瓶颈，所以我需要加快速度。

我尝试了很多简单的选项，目前正在使用这个：

foreach (var index in firstSet)
{
    if (secondSet.BinarySearch(index) < 0)
        continue;

    //do stuff
}

firstSet 和 secondSet 都是 List 类型。

我也尝试过使用 LINQ：

var intersection = firstSet.Where(t => secondSet.BinarySearch(t) >= 0).ToList();

然后循环遍历intersection。

但是由于这两个集合都已排序，我觉得有更好的方法来做到这一点。请注意，我无法从集合中删除项目以使其更小。两组通常各包含大约 50 件物品。

请帮帮我，因为我没有太多时间来完成这件事。谢谢。

注意：我这样做了大约 530 万次。所以每一微秒都很重要。

Answer 1

如果您有两个都已排序的集合，则可以实现比 LINQ 开箱即用的任何方法更快的交集。

基本上，保持两个IEnumerator<T> 光标打开，每组一个。在任何时候，以较小的价值前进。如果它们在任何时候都匹配，则将它们都推进，依此类推，直到到达任一迭代器的末尾。

这样做的好处是您只需对每个集合迭代一次，并且可以在 O(1) 内存中完成。

这是一个示例实现 - 未经测试，但它确实可以编译 :) 它假定两个传入的序列都是无重复的且已排序，都根据提供的比较器（传入Comparer<T>.Default）：

（答案末尾有更多文字！）

static IEnumerable<T> IntersectSorted<T>(this IEnumerable<T> sequence1,
    IEnumerable<T> sequence2,
    IComparer<T> comparer)
{
    using (var cursor1 = sequence1.GetEnumerator())
    using (var cursor2 = sequence2.GetEnumerator())
    {
        if (!cursor1.MoveNext() || !cursor2.MoveNext())
        {
            yield break;
        }
        var value1 = cursor1.Current;
        var value2 = cursor2.Current;

        while (true)
        {
            int comparison = comparer.Compare(value1, value2);
            if (comparison < 0)
            {
                if (!cursor1.MoveNext())
                {
                    yield break;
                }
                value1 = cursor1.Current;
            }
            else if (comparison > 0)
            {
                if (!cursor2.MoveNext())
                {
                    yield break;
                }
                value2 = cursor2.Current;
            }
            else
            {
                yield return value1;
                if (!cursor1.MoveNext() || !cursor2.MoveNext())
                {
                    yield break;
                }
                value1 = cursor1.Current;
                value2 = cursor2.Current;
            }
        }
    }
}

编辑：如 cmets 中所述，在某些情况下，您的一个输入可能比另一个大得多，在这种情况下，您可以使用二进制搜索从较小集合中的每个元素节省大量时间更大的集合。然而，这需要随机访问更大的集合（这只是二进制搜索的先决条件）。您甚至可以通过使用 previous 结果中的匹配来为二进制搜索提供下限，使其比简单的二进制搜索稍好一些。因此，假设您在一个集合中查找值 1000、2000 和 3000，每个整数都从 0 到 19,999。在第一次迭代中，您需要查看整个集合 - 您的起始下/上索引将分别为 0 和 19,999。然而，当您在索引 1000 处找到匹配项后，下一步 步骤（您正在寻找 2000 的位置）可以从较低的索引 2000 开始。随着您的进步，您的范围需要搜索逐渐缩小。然而，这是否值得额外的实施成本是另一回事。

Answer 2

由于两个列表都已排序，因此您最多可以通过迭代它们一次来获得解决方案（您也可能会跳过一个列表的一部分，具体取决于它们包含的实际值）。

这个解决方案保留了一个指向我们尚未检查的列表部分的“指针”，并比较它们之间每个列表的第一个未检查的数字。如果一个小于另一个，则指向它所属列表的指针递增以指向下一个数字。如果它们相等，则将数字添加到交集结果中，并且两个指针都递增。

var firstCount = firstSet.Count;
var secondCount = secondSet.Count;
int firstIndex = 0, secondIndex = 0;
var intersection = new List<int>();

while (firstIndex < firstCount && secondIndex < secondCount)
{
    var comp = firstSet[firstIndex].CompareTo(secondSet[secondIndex]);
    if (comp < 0) {
        ++firstIndex;
    }
    else if (comp > 0) {
        ++secondIndex;
    }
    else {
        intersection.Add(firstSet[firstIndex]);
        ++firstIndex;
        ++secondIndex;
    }
}

以上是解决此特定问题的教科书 C 风格方法，鉴于代码的简单性，我会惊讶地看到更快的解决方案。

Answer 3

您正在为此类任务使用效率相当低的 Linq 方法，您应该选择 Intersect 作为起点。

var intersection = firstSet.Intersect(secondSet);

试试这个。如果你衡量它的性能，但仍然觉得它笨拙，请寻求进一步的帮助（或者也许遵循 Jon Skeet 的方法）。

Answer 4

我使用的是 Jon 的方法，但需要在非常大的集合上执行此相交数十万次的批量操作，并且需要更高的性能。我遇到的情况是列表的大小严重不平衡（例如 5 和 80,000），并且希望避免迭代整个大列表。

我发现检测不平衡并更改为替代算法给了我对特定数据集的巨大好处：

public static IEnumerable<T> IntersectSorted<T>(this List<T> sequence1,
        List<T> sequence2,
        IComparer<T> comparer)
{
    List<T> smallList = null;
    List<T> largeList = null;

    if (sequence1.Count() < Math.Log(sequence2.Count(), 2))
    {
        smallList = sequence1;
        largeList = sequence2;
    }
    else if (sequence2.Count() < Math.Log(sequence1.Count(), 2))
    {
        smallList = sequence2;
        largeList = sequence1;
    }

    if (smallList != null)
    {
        foreach (var item in smallList)
        {
            if (largeList.BinarySearch(item, comparer) >= 0)
            {
                yield return item;
            }
        }
    }
    else
    {
        //Use Jon's method
    }
}

我仍然不确定你的收支平衡点，需要做更多的测试

Answer 5

试试

firstSet.InterSect (secondSet).ToList ()

或

firstSet.Join(secondSet, o => o, id => id, (o, id) => o)