计算 List<List<T>> 中的元素个数

Question

我有一个List<List<T>>。 如何以最快的方式计算其中的所有元素，就好像它是单个 List<T> 一样？

到目前为止我已经使用了

List<int> result = listOfLists
  .SelectMany(list => list)
  .Distinct()
  .ToList().Count;

但这实际上是创建一个列表然后计算元素，这不是一个好主意。

Answer 1

通过使用 LINQ，我认为您的代码很好，不需要.ToList()，只需调用Count() 扩展，如下所示：

int result = listOfLists.SelectMany(list => list).Distinct().Count();

Answer 2

如果您需要消除列表之间的重复项，我建议您使用带有 HashSet 的简单嵌套循环。它将 SelectMany 和 Distinct 操作组合到集合插入逻辑中，并且应该更快，因为 HashSet 具有 O(1) 查找时间。内部 Distinct() 可能实际上使用了类似的东西，但这完全省略了单个列表的构造。

var set = new HashSet<T>();
foreach (var list in listOfLists)
{
    foreach (var item in list)
    {
        set.Add(item);
    }
}
var result = set.Count;

Answer 3

要计算列表中所有列表中的所有元素，您可以使用聚合运算符：

int count = listOfLists.Sum(l => l.Distinct().Count());

Answer 4

我想有机会回答这个问题，只是为了强调什么时候应该使用 linq 以及什么时候应该使用经典 for。 不幸的是，今天人们并不关心性能，因为我们习惯于在非常强大的计算机上工作。不管怎样，只要试试下面的代码，你就会发现 Linq 比经典的 for 版本慢 100 倍以上。仅当您需要编写的表达式非常复杂并且希望使其更具可读性时，才应使用 Linq。 我没有花时间在下面介绍的解决方案上，因为我想专注于性能

public static void Main(string [] arg)
{
    //create the list
    List<List<string>> listOfList = new List<List<string>>()
                                      {
                                          new List<string>()
                                              {
                                                  "1.1","2.2"
                                              }
                                      ,
                                       new List<string>()
                                              {
                                                  "2.1","2.2","2.3"
                                              }
                                      };
    //stopwatch using Linq
    Stopwatch stopwatch=new Stopwatch();
    stopwatch.Start();

    int totalUsingLinq = listOfList.Sum(x => x.Count);

    stopwatch.Stop();
    Console.WriteLine("Using Linq:{0}",stopwatch.Elapsed); //00005713

    int totalUsingFor = 0;
    //stopwatch using classic for 
    stopwatch.Reset();
    stopwatch.Start();
    totalUsingFor = 0;
    for(int i=0;i<listOfList.Count;i++)
    {
       var mainItem = listOfList[i];
        if(mainItem!=null)
        {
            totalUsingFor += mainItem.Count;
        }
    }
    stopwatch.Stop();
    Console.WriteLine("Using for:{0}", stopwatch.Elapsed); //0000010

}

使用 for 的不同版本（仅作为示例）。 在这种情况下，我创建了一个非常“瓶颈”的功能，它可以做到与众不同，而且速度更快。

 public class Program
    {
      public static void Main(string[] arg)
        {
            //create the list
            List<List<string>> listOfList = new List<List<string>>()
                                      {
                                          new List<string>()
                                              {
                                                  "1.1","2.2","1.1","1.1","2.2","1.1","1.1","2.2","1.1","1.1"
                                              }
                                      ,
                                       new List<string>()
                                              {
                                                  "2.1","2.2","2.3","2.3","1.1","2.2","1.1","1.1","2.2","1.1","1.1","2.2","1.1","1.1","2.2","1.1","1.1","2.2","1.1"
                                              }
                                      };
            //stopwatch using Linq
            Stopwatch stopwatch = new Stopwatch();
            stopwatch.Start();

            int totalUsingLinq = listOfList.Sum(l => l.Distinct().Count());


            stopwatch.Stop();
            Console.WriteLine("Using Linq:{0}", stopwatch.Elapsed); //000012150    
            int totalUsingFor = 0;
            //stopwatch using classic for 
            stopwatch.Reset();
            stopwatch.Start();
            totalUsingFor = 0;
            for (int i = 0; i < listOfList.Count; i++)
            {
                var mainItem = listOfList[i];
                if (mainItem != null)
                {
                    for(int y=0;y<mainItem.Count;y++)
                    {
                      if(mainItem[y]!=null)
                      {
                          totalUsingFor++;
                          NullDuplicateItems(y, ref mainItem);
                      }   
                    }
                }
            }
            stopwatch.Stop();
            Console.WriteLine("Using for:{0}", stopwatch.Elapsed); //0009440
        }

        public static void NullDuplicateItems(int index,ref List<string > list)
        {
            var item = list[index];
            for(int i=index+1;i<list.Count;i++)
            {
                if(list[i]==item)
                {
                    list[i] = null;
                }
            }
        }

    }