0

我有一个包含 ~137000 条记录的实体列表，我循环遍历这些记录，然后我需要 linq 到包含 ~ 150000 的附加参数的元组列表

为什么它持续花费更长的时间，它的迭代次数越多？这是从秒表中找到的：136770 个符合条件的项目。

10,000 个项目处理 EllapsedTime：5473 即：0.0912166666666667 分钟。

20,000 个项目已处理 EllapsedTime：15307 即：0.255116666666667 分钟。

30,000 个项目已处理 EllapsedTime：30065 即：0.501083333333333 分钟。

50,000 个项目已处理 EllapsedTime：74507 即：1.24178333333333 分钟。

75,000 个项目已处理 EllapsedTime：157836 即：2.6306 分钟。

100,000 个项目处理 EllapsedTime：272495 即：4.54158333333333 分钟。

EllapsedTime：499663即：8.32771666666667分钟。

有什么办法可以优化吗？

 List<Entites> alMatched 
List<Tuple<int, double, int, int>> lsItems = new List<Tuple<int, double, int, int>>();
IEnumerable<Tuple<int, double, int, int>> enumThingy = lsItems;

 for (int z = 0; z <= alMatched.Count() - 1;z++ )
            {
               Entity a = alMatched[z];
               var newRepl = enumThingy.Where(d => d.First == a.ID).First();
               if (newRepl != null)
               {

               }

                switch (z)
                {
                    case 10000:
                        Debug.Print("10,000 items processed " + ElapsedTime(sw.ElapsedMilliseconds));
                        break;
                    case 20000:
                        Debug.Print("20,000 items processed " + ElapsedTime(sw.ElapsedMilliseconds));
                        break;
                    case 30000:
                        Debug.Print("30,000 items processed " + ElapsedTime(sw.ElapsedMilliseconds));
                        break;
                    case 50000:
                        Debug.Print("50,000 items processed " + ElapsedTime(sw.ElapsedMilliseconds));
                        break;
                    case 75000:
                        Debug.Print("75,000 items processed " + ElapsedTime(sw.ElapsedMilliseconds));
                        break;
                    case 100000:
                        Debug.Print("100,000 items processed " + ElapsedTime(sw.ElapsedMilliseconds));
                        break;
                }

            }

问候

_埃里克

4

3 回答 3

2

看看这段代码：

for (int z = 0; z <= alMatched.Count() - 1;z++ )
{
    Entity a = alMatched[z];
    var newRepl = enumThingy.Where(d => d.First == a.ID).First();

在这种情况下（我怀疑您的“真实”案例）， theenumThingy和alMatchedenumerables 的顺序相同。

因此，当您在案例 1 中时，enumThingy.Where对第一次迭代的调用会返回。在案例 100 中，需要 100 次迭代才能匹配您的条件，然后退出。在案例 10000 上，它需要 10000 次迭代。

基本上，你走得越远，情况就越糟。您的算法是 O(N^2)，但 LINQ 是捷径，因为您使用的是相同的列表，并且排序帮助您快速“捷径”摆脱困境。

于 2009-09-17T20:45:58.130 回答
1

当然。尝试字典而不是列表

    List<Tuple<int, double, int, int>> lsItems = new List<Tuple<int, double, int, int>>();

//should be 

var lsItems = new Dictionary<int, Tuple<int, double, int, int>>();

/引用这些项目：

var newRepl = lsItems[a.ID];

于 2009-09-17T20:46:45.697 回答
0

您可以在此处使用不同的方法来实现速度增益。

一种是使用哈希表将项目存储在 enumThingy 中，并通过您要查找的密钥访问它们。

另一种选择是对 enumthingee 进行排序并对 alMatched 进行排序，然后使用“滑动方法”来查找您需要的所有项目。

目前您正在处理一个枚举，它必须检查所有项目以找到您需要的项目，因此您的项目位于链中的后期（或完全丢失）将花费越来越多的时间

于 2009-09-17T20:48:20.283 回答