.NET 泛型 - 比较两个列表和过滤器：最佳实践

Question

我有两个 T 类型的通用列表。两个列表都包含相同的类型，我想根据列表 2 中不存在的项目创建第三个列表（或列表 2 的过滤版本） 1，基于每个项目的ID。

每个列表都包含一个“包”对象，该对象具有一个 ID 属性。

现在我使用 For Each 循环来模拟代码，我知道这很糟糕（大 O 是常数时间），所以我想要一个更有效的方法。

根据项目要求，此代码在 VB 中，但我更喜欢 C# - 所以任何一个代码示例都适合我。

Private Sub RemoveStockPackagesFromSelection()

    Dim p As Package
    Dim packageList As List(Of Package) = New List(Of Package)
    Dim stockPackageList As List(Of Package) = New List(Of Package)
    Dim result As List(Of Package) = New List(Of Package)

    ' Fill list with User's Packages
    For i As Integer = 0 To ListBox2.Items.Count - 1
        p = New Package
        p.Id = CInt(ListBox2.Items(i).Value)
        p.Name = ListBox2.Items(i).Text
        packageList.Add(p)
    Next

    ' Fill list with Stock Packages to compare:
    Dim ds As DataSet = DAL.GetStandardPackages()

    For Each dr As DataRow In ds.Tables(0).Rows
        p = New Package
        p.Id = CInt(dr.Item("id"))
        stockPackageList.Add(p)
    Next

    ' Do Compare and Filter
    For Each p1 As Package In packageList
        For Each p2 As Package In stockPackageList
            If Not p1.Id = p2.Id Then
                result.Add(p2)
            End If
        Next
    Next

    ' Here is our new trimmed list:
    Response.Write(result.Count)

End Sub

什么是进行这种过滤的干净利落的 LINQ 或 Lamda 方式？我的方法的大 O 是什么，建议的方法的大 O 是什么（只是为了满足我的好奇心）。

谢谢

Answer 1

LINQ 除外方法

这将是最干净的方式，正如 Maxim 和 svick 所建议的那样，但需要一个重写的等于 ID 的 Equals 方法，或者您必须提供一个比较器（请参阅 svicks 答案）。

var result = stockPackageList.Except(packageList).ToList();

资源 许多 LINQ 示例可以在 http://msdn.microsoft.com/en-us/vcsharp/aa336746 的 msdn 中找到

---

我会将答案的开头部分留作参考：

蛮力方式：

var result = stockPackageList
              .Where(x => packageList.All(package => x.Id != package.Id))
              .ToList();

应该可以解决问题。您只需要将 lambda 语法转换为 vb.net。

此查询将过滤来自 stockPackageList 的所有项目，这些项目的 ID 不存在于 packageList 的所有项目中。

您可以反转查询：

var result = stockPackageList
              .Where(x => packageList.Any(package => x.Id == package.Id) == false)
              .ToList();

如果packageList 中的任何项目具有匹配的 id，Any 查询将返回 true。这个查询应该运行得更快一些，因为它不必像All 那样遍历整个集合。

使用平等：

如果您的包对象实现了IEquatable<Package>，您可以将代码缩短为

var result = stockPackageList
              .Where(x => packageList.Contains(x) == false)
              .ToList();

使用哈希集：

如果你想使用哈希集，你可以这样做

var hash = new HashSet<string>(packageList.Select(x=>x.Id));
var result = stockPackageList.Where(x => hash.Contains(x.Id) == false).ToList();

正如 faester 和 Ivan Danilov 指出的那样，当列表变大时，这可以节省计算时间。

Answer 2

无法真正阅读您的 VB 代码，但如果您想获取 l2 中的项目而不是 l1 中的项目 -

她是一个示例 C# 代码

   public class SomeObject
    {
        public string ID { get; set; }
    }

    public class SomeObjectComparer : IEqualityComparer<SomeObject>
    {
        public bool Equals(SomeObject x, SomeObject y)
        {
            return x.ID == y.ID;
        }

        public int GetHashCode(SomeObject obj)
        {
            return obj.ID.GetHashCode();
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            List<SomeObject> l1, l2;
            // lists init ...

            IEqualityComparer<SomeObject> comparer = new SomeObjectComparer();

            List<SomeObject> l3 = l2.Except(l1, comparer).ToList();

        }
    }

Answer 3

您的方法具有 O(m*n) 的渐近运行时间，其中 m 和 n 是您的集合的大小。

你应该争取 O(m lg n)。您当然需要搜索这两个集合，但是您可以在 O(n) 中构建其中一个的哈希集并在平均 O(1) 中执行查询，因此您应该将一个列表复制到哈希集并遍历第二个查找提高前者的价值。

    static void Sort()
    {
        List<Package> a = new List<Package>();
        List<Package> b = new List<Package>();

        Func<Package, int> idExtractor = x => x.ID;

        var hash = new HashSet<Package>(a, new IDComparer<Package, int>(idExtractor));

        a.AddRange(b.Where(x => !hash.Contains(x)));
    }

    class IDComparer<ObjectType, KeyType>
        : IEqualityComparer<ObjectType>
        where KeyType : IComparable
    {
        private Func<ObjectType, KeyType> idExtractor;

        public IDComparer(Func<ObjectType, KeyType> idExtractor)
        {
            this.idExtractor = idExtractor;
        }

        public bool Equals(ObjectType x, ObjectType y)
        {
            return idExtractor(x).Equals(idExtractor(y));
        }

        public int GetHashCode(ObjectType obj)
        {
            return idExtractor(obj).GetHashCode();
        }
    }

Answer 4

你可以使用Except():

result = stockpackageList.Except(PackageList).ToList();

这假定Package 已重载Equals() 以比较Ids。如果没有，您必须使用IEqualityComparer，例如来自this answer的那个：

result = stockpackageList.Except(PackageList, 
                                 new KeyEqualityComparer<Package, int>(p => p.Id))
                         .ToList();

至于时间复杂度，您的解决方案无法正常工作，因此它的复杂度无关紧要。 Except() 的复杂度是 O(N+M)，因为它首先从第一个集合中创建一个哈希集 (O(N))，然后尝试从第二个集合中删除每个项目 (O(M))，然后返回结果。

Answer 5

var dic = new Dictionary<string, Package>(p1.Count); // capacity here is important
foreach (var p in p1) 
    dic.Add(p.Id, p);
var result = p2.Where(p => !dic.ContainsKey(p.Id)).ToList();

填充字典几乎 O(n) by p1.Count。每次搜索都是 O(1)。所以我们有一些接近线性复杂度的东西。