在 .NET 2.0 中组合两个 List 的好方法是什么?

发布于 2024-08-12 01:07:04 字数 89 浏览 4 评论 0 原文

我有两个列表需要形成并集,但我使用的是 .NET 2.0,因此 Union() 方法似乎已失效。这些是整数列表,因此相等比较没有问题。解决这个问题有什么好的方法吗?

I have two lists I need to form the union of, but I'm in .NET 2.0 so the Union() method appears to be out. These are lists of integers, so no problem with the equality comparisons. What's a good way to go about this?

如果你对这篇内容有疑问,欢迎到本站社区发帖提问 参与讨论,获取更多帮助,或者扫码二维码加入 Web 技术交流群。

扫码二维码加入Web技术交流群

发布评论

需要 登录 才能够评论, 你可以免费 注册 一个本站的账号。

评论(4

别忘他 2024-08-19 01:07:04

您可以将它们添加在一起并删除重复项:

  public List<T> Union<T>(List<T> firstList, List<T> secondList)
  {
     Dictionary<T, int> tmp = new Dictionary<T, int>();

     foreach (T val in firstList)
     {
        tmp[val] = 1;
     }

     foreach (T val in secondList)
     {
        tmp[val] = 1;
     }

     return new List<T>(tmp.Keys);
  }

You could just add them together and remove the duplicates:

  public List<T> Union<T>(List<T> firstList, List<T> secondList)
  {
     Dictionary<T, int> tmp = new Dictionary<T, int>();

     foreach (T val in firstList)
     {
        tmp[val] = 1;
     }

     foreach (T val in secondList)
     {
        tmp[val] = 1;
     }

     return new List<T>(tmp.Keys);
  }
你对谁都笑 2024-08-19 01:07:04

怎么样(使用字典键作为哈希表):

public static List<T> Union<T>(List<T> first, List<T> second) {
    List<T> newList = new List<T>(first.Count + second.Count);
    Dictionary<T, object> firstItems = new Dictionary<T, object>(first.Count);

    foreach (T item in first) {
        newList.Add(item);
        firstItems.Add(item, null); 
    }

    foreach (T item in second) {
        if (!firstItems.ContainsKey(item)) {
            newList.Add(item);
        }
    }

    return newList;
}

这将维持 firstsecond 中的项目顺序,同时仍然使用 O(1) 检查两个之间的重复项目。列表

What about (using Dictionary keys as a hashtable):

public static List<T> Union<T>(List<T> first, List<T> second) {
    List<T> newList = new List<T>(first.Count + second.Count);
    Dictionary<T, object> firstItems = new Dictionary<T, object>(first.Count);

    foreach (T item in first) {
        newList.Add(item);
        firstItems.Add(item, null); 
    }

    foreach (T item in second) {
        if (!firstItems.ContainsKey(item)) {
            newList.Add(item);
        }
    }

    return newList;
}

This will maintain the item order in first and second, while still using an O(1) check for duplicate items between the lists

人间☆小暴躁 2024-08-19 01:07:04

一个简单的 foreach 怎么样,仅添加列表中尚未存在的元素:

foreach (int item in list2)
{
    if (!list1.Contains(item))
    {
        list1.Add(item);
    }
}

这将保留列表的顺序。

How about a simple foreach, only adding elements that aren't already in the list:

foreach (int item in list2)
{
    if (!list1.Contains(item))
    {
        list1.Add(item);
    }
}

This will preserve the order of the lists.

最舍不得你 2024-08-19 01:07:04

您可以使用 linqbridge 让您在仍以 Framework 2.0 为目标的情况下使用 LINQ to Objects,如果您有 Visual Studio 2008。

并推动、推动、推动迁移到 .NET 3.5。 LINQ 和 lambda 改变了您思考代码的方式(恕我直言,是为了更好)。

You could use linqbridge to let you use LINQ to Objects while still targeting Framework 2.0, if you have Visual Studio 2008.

And push, push, push to move to .NET 3.5. LINQ and lambdas change the way you think about code (for the better, IMHO).

~没有更多了~
我们使用 Cookies 和其他技术来定制您的体验包括您的登录状态等。通过阅读我们的 隐私政策 了解更多相关信息。 单击 接受 或继续使用网站,即表示您同意使用 Cookies 和您的相关数据。
原文