遍历 2 个列表

Question

我有一个 List<T1> 的项目和第二个 List<T2> 的项目。两个列表都按属性 A 的字母顺序排序。我知道 List<T2> 中的项目列表是 List<T1> 的子集，List<T2> 中不存在 List<T1> 中不存在的项目。

我需要遍历List<T1> 并在每次匹配List<T2> 中的变量时更改一个变量。最快最好的方法是什么？我假设我需要遍历这两个列表，但我知道做一个嵌套的 foreach 没有意义。

Answer 1

对于这种类型的事情，我更喜欢双循环 for 循环。请参阅下面的示例。

var super = new List<Contact>();
super.Add(new Contact() {Name = "John"});
super.Add(new Contact() {Name = "Larry"});
super.Add(new Contact() {Name = "Smith"});
super.Add(new Contact() {Name = "Corey"});

var sub = new List<Contact>();
sub.Add(new Contact() {Name = "Larry"});
sub.Add(new Contact() {Name = "Smith"});

var subCount = 0;
for(int i=0; i<super.Count && subCount < sub.Count; i++)
{
    if (super[i].Name == sub[subCount].Name)
    {
        Act(super[i], sub[subCount]);
        subCount++;
    }
}

Act(...) 执行您想要执行的任何操作。

循环每次都会增加超级列表，但只有在找到匹配项时才会增加子列表。

请注意，这只适用于您的两个假设。 1) 列表均已排序，并且 2) 第二个列表是第一个列表的子集。

Answer 2

如果列表不是太大，最简单的方法是调用Contains：

foreach(var item in list1) {
    if (list2.Contains(item) {
        //Do something
    }
}

您可以通过使用自定义IComparer<T> 调用BinarySearch 来加快速度，如下所示：

class MyComparer : IComparer<YourClass> {
    private MyComparer() { }
    public static readonly MyComparer Instance = new MyComparer();

    public int CompareTo(YourClass a, YourClass b) {
        //TODO: Handle nulls
        return a.SomeProperty.CompareTo(b.SomeProperty);
    }
}
foreach(var item in list1) {
    if (list2.BinarySearch(item, MyComparer.Instance) >= 0) {
        //Do something
    }
}

在 .Net 3.5 中，您可以使用 HashSet<T> 使其更快：

var hashset = new HashSet<YourClass>(list2);
foreach(var item in list1) {
    if (hashset.Contains(item) {
        //Do something
    }
}

如果您的列表非常大，您应该衡量每个选项的效果并做出相应选择。
否则，请选择第一个选项，这是最简单的。

Answer 3

您的问题意味着您希望避免每次都遍历第二个列表中的所有项目，这在使用Contains() 的最坏情况的幼稚解决方案中会发生这种情况。由于两个列表都已排序并且list2 是list1 的子集，因此您知道list1 中的任何条目的索引都不会小于list2 中的相应条目的索引。考虑到这一点，您可以使用两个枚举器制作一个有效的 O(n) 解决方案：

Debug.Assert(list1.Count > 0);
Debug.Assert(list1.Count >= list2.Count);

var enum1 = list1.GetEnumerator();
var enum2 = list2.GetEnumerator();

enum1.MoveNext();
while (enum2.MoveNext())
{
    // Skip elements from list1 that aren't equal to the current entry in list2
    while (!enum1.Current.Equals(enum2.Current))
        enum1.MoveNext();

    // Fire the OnEqual event for every entry in list1 that's equal to an entry
    // in list2
    do {
        OnEqual(enum1.Current, enum2.Current); 
    } while (enum1.MoveNext() && enum1.Current.Equals(enum2.Current));
}

enum1.Dispose();
enum2.Dispose();

Answer 4

如果它们都按唯一属性排序，则可以在迭代期间使用它。这个想法是遍历超集，然后根据该排序的唯一属性推进子集迭代器，直到它与超集匹配或大于/小于（取决于排序顺序）。

对于按升序排序的属性：

if (subsetList.Count > 0)
{
    using(IEnumerator<T2> subset = subsetList.GetEnumerator())
    {
        subset.MoveNext();
        T2 subitem = subsetList.Current;
        foreach(T1 item in supersetList)
        {
            while (item.A > subitem.A &&
                   subset.MoveNext())
            {
                subitem = subset.Current;
            }

            if (item.A == subitem.A)
            {
                // Modify item here.
            }
        }
    }
}

请注意，这实际上并不依赖于 supersetList 是 subsetList 的超集。 EndangeredMassa 的解决方案更简洁，假设成立。