3

我有一种情况，我生成了许多包含整数值的列表。但是，这些列表的数量只有在运行时才知道，并且结果列表中存在的整数必须存在于所有列表中。有没有一种方法可以将所有这些列表加入到一个列表中？

IE

List<int> l1 = {1, 2, 3, 4};
List<int> l2 = {2, 3, 5, 7, 9};
List<int> l3 = {3, 9, 10};
List<int> ln = {....};

结果列表应如下所示

List<int> r = {3};

linq 或任何其他方法可以做到这一点吗？

4

3 回答 3

5

我假设你有一个List<List<int>>持有可变数量的List<int>.

您可以将第一个列表与第二个列表相交

var intersection = listOfLists[0].Intersect(listOfLists[1]);

然后将结果与第三个列表相交

intersection = intersection.Intersect(listOfLists[2]);

依此类推，直到intersection拥有所有列表的交集。

intersection = intersection.Intersect(listOfLists[listOfLists.Count - 1]);

使用for循环：

IEnumerable<int> intersection = listOfLists[0];

for (int i = 1; i < listOfLists.Count; i++)
{
    intersection = intersection.Intersect(listOfLists[i]);
}

使用foreach循环（如@lazyberezovsky所示）：

IEnumerable<int> intersection = listOfLists.First();

foreach (List<int> list in listOfLists.Skip(1))
{
    intersection = intersection.Intersect(list);
}

使用Enumerable.Aggregate：

var intersection = listOfLists.Aggregate(Enumerable.Intersect);

如果顺序不重要，那么您还可以使用HashSet<T>填充第一个列表并与其余列表相交（如@Servy所示）。

var intersection = new HashSet<int>(listOfLists.First());

foreach (List<int> list in listOfLists.Skip(1))
{
    intersection.IntersectWith(list);
}
于 2013-02-20T16:29:55.753 回答
1 
// lists is a sequence of all lists from l1 to ln
if (!lists.Any())
   return new List<int>();

IEnumerable<int> r = lists.First();   

foreach(List<int> list in lists.Skip(1))    
   r = r.Intersect(list);

return r.ToList();
于 2013-02-20T16:29:53.050 回答
0

这是获取集合集合交集的简单方法：

public static IEnumerable<T> Intersect<T>(IEnumerable<IEnumerable<T>> sequences)
{
    using (var iterator = sequences.GetEnumerator())
    {
        if (!iterator.MoveNext())
            return Enumerable.Empty<T>();

        HashSet<T> intersection = new HashSet<T>(iterator.Current);

        while (iterator.MoveNext())
            intersection.IntersectWith(iterator.Current);

        return intersection;
    }
}

这里的想法是将所有项目放入一个集合中，然后依次与该集合与每个序列相交。我们可以使用普通的 LINQ 用更少的代码来做到这一点，但这将从HashSet每个交叉点的结果中填充一个新的，而不是重用一个，因此尽管看起来非常优雅，但它的开销会高得多。

这是性能较差但更优雅的解决方案：

public static IEnumerable<T> Intersect<T>(IEnumerable<IEnumerable<T>> sequences)
{
    return sequences.Aggregate(Enumerable.Intersect);
}
于 2013-02-20T16:37:19.527 回答