提高当前 Linq 查询的时间复杂度

Question

我有以下列表：

RakeSnapshots, ProductMovements

目的是对两者进行处理，得到符合条件的元素个数，如下：

• 考虑RakeSnapshots 和StatusCode == "Dumping"

• 考虑ProductMovement 和Status == "InProgress"

• 获取两个列表中满足RakeSnapshots.RakeCode等于ProductMovements.ProductCode条件的所有元素的count

以下是我目前的选择：

// 代码1：

 var resultCount =  ProductMovements.Where(x => RakeSnapshots
                                                .Where(r => r.StatusCode == "Dumping")
                                                .Any(y => y.RakeCode == x.ProductCode  && 
                                                          x.Status == "InProgress"))
                                                .Count();

// 代码2：

var productMovementsInprogress = ProductMovements.Where(x => x.Status == "InProgress");

var rakeSnapShotsDumping = RakeSnapshots.Where(r => r.StatusCode == "Dumping");

var resultCount = productMovementsInprogress.Zip(rakeSnapShotsDumping,(x,y) => (y.RakeCode == x.ProductCode) ?  true : false)
                                            .Where(x => x).Count();

挑战是两个代码都是O(n^2)复杂度，有没有办法改进它，如果数据很大，这会伤害

Answer 1

您可以使用inner join 来执行此操作：

var dumpingRakeSnapshots       = rakeSnapshots.Where(r => r.StatusCode == "Dumping");
var inProgressProductMovements = productMovements.Where(p => p.Status == "InProgress");

var matches =
    from r in dumpingRakeSnapshots
    join p in inProgressProductMovements on r.RakeCode equals p.ProductCode
    select r;

int count = matches.Count(); // Here's the answer.

请注意（正如 Ivan Stoev 指出的那样）这仅在 RakeCode 是 RakeSnapshots 的主键时才有效。

如果不是，您将不得不使用grouped join。

这是您在这种情况下应该使用的 Linq 查询语法版本，但请注意，这与 Ivan 的答案完全相同（仅在 Linq 查询形式中）：

var matches =
    from r in dumpingRakeSnapshots
    join p in inProgressProductMovements on r.RakeCode equals p.ProductCode into gj
    select gj;

---

为了完整起见，这里有一个可编译的控制台应用程序，演示了如果 RakeCode 和 ProductCode 不是主键，您将获得不同的结果：

using System;
using System.Collections.Generic;
using System.Linq;

namespace ConsoleApp1
{
    class RakeSnapshot
    {
        public string StatusCode;
        public string RakeCode;
    }

    class ProductMovement
    {
        public string Status;
        public string ProductCode;
    }

    sealed class Program
    {
        void run()
        {
            var rakeSnapshots = new List<RakeSnapshot>
            {
                new RakeSnapshot {StatusCode = "Dumping", RakeCode = "1"},
                new RakeSnapshot {StatusCode = "Dumping", RakeCode = "1"},
                new RakeSnapshot {StatusCode = "Dumping", RakeCode = "2"}
            };

            var productMovements = new List<ProductMovement>
            {
                new ProductMovement {Status = "InProgress", ProductCode = "1"},
                new ProductMovement {Status = "InProgress", ProductCode = "2"},
                new ProductMovement {Status = "InProgress", ProductCode = "2"}
            };

            var dumpingRakeSnapshots       = rakeSnapshots.Where(r => r.StatusCode == "Dumping");
            var inProgressProductMovements = productMovements.Where(p => p.Status == "InProgress");

            // Inner join.

            var matches1 =
                from r in dumpingRakeSnapshots
                join p in inProgressProductMovements on r.RakeCode equals p.ProductCode
                select r;

            Console.WriteLine(matches1.Count());

            // Grouped join.

            var matches2 =
                from r in dumpingRakeSnapshots
                join p in inProgressProductMovements on r.RakeCode equals p.ProductCode into gj
                select gj;

            Console.WriteLine(matches2.Count());

            // OP's code.

            var resultCount = 
                productMovements
                .Count(x => rakeSnapshots
                .Where(r => r.StatusCode == "Dumping")
                .Any(y => y.RakeCode == x.ProductCode && x.Status == "InProgress"));

            Console.WriteLine(resultCount);
        }

        static void Main(string[] args)
        {
            new Program().run();
        }
    }
}

Answer 2

听起来像Group Join（以及Join）是关联两组的最有效的LINQ方法：

var resultCount = ProductMovements.Where(p => p.Status == "InProgress")
    .GroupJoin(RakeSnapshots.Where(r => r.StatusCode == "Dumping"), 
        p => p.ProductCode, r => r.RakeCode, (p, match) => match)
    .Count(match => match.Any());

上面的时间复杂度是O(N+M)。

Answer 3

通常，使用 O(N^2)，您会希望创建一个中间“搜索”数据结构来加快查找速度。类似于 O(1) 访问的哈希表，或 O(log N) 访问的排序列表。

从技术上讲，您有两个不同的列表，因此实际顺序为 O(P.R)，其中 P 是产品移动的数量，R 是 rake 快照的数量。

在您的情况下，这是您的原始代码；

var resultCount =  ProductMovements
    .Where(x => RakeSnapshots
        .Where(r => r.StatusCode == "Dumping")
        .Any(y => y.RakeCode == x.ProductCode  && 
                  x.Status == "InProgress"))
        .Count();

是 O(PR)，因为对于每个 P，内部 where 子句循环通过每个 R。我希望创建一个 Dictionary<T> 或 HashSet<T>，然后将您的代码转换为类似的东西

var rakeSnapshotSummary = ... magic happens here ...;
var resultCount =  ProductMovements
    .Where(x => rakeSnapshotSummary[x.ProductCode] == true)
    .Count();

这样，创建快照是 O(R)，查找数据结构是 O(1)，创建结果是 O(P)，更健康的 O(P+R)。我认为这是最好的。

所以我对你的索引例程的建议是这样的；

var rakeSnapshotSummary = new HashSet<string>(RakeSnapshots
    .Where(r => r.StatusCode == "Dumping")
    .Select(r => r.RakeCode));

这将创建一个HashSet<string>，它具有 O(1) 的时间复杂度来测试 rake 代码的存在性。然后你的最后一行看起来像

var resultCount =  ProductMovements
    .Where(x => x.Status == "InProgress" && rakeSnapshotSummary.Contains(x.ProductCode))
    .Count();

所以总体而言，O(P+R) 或粗略地说，O(2N) => O(N)。