如何将ArrayList去重合并方法修改为LinkedList实现？

Great question! Let's adjust your existing method to work with LinkedList<T> (we'll start with LinkedList<object> to match your original non-generic ArrayList approach, then share an optimized and type-safe version too). Here's the breakdown:

Basic Adaptation (Direct Conversion) #

First, here's the modified method that aligns with LinkedList<object> while fixing small edge cases from your original code:

// Merge two LinkedLists to the first one without duplication
public static void MergeIntoFirst(LinkedList<object> list1, LinkedList<object> list2)
{
    // Fix null handling: specify which parameter is null for clearer debugging
    if (list1 == null)
        throw new ArgumentNullException(nameof(list1));
    if (list2 == null)
        throw new ArgumentNullException(nameof(list2));
    
    // Exit early if both references point to the exact same list
    if (ReferenceEquals(list1, list2))
        return;

    // Iterate over list2 and add elements not present in list1
    foreach (var obj in list2)
    {
        if (!list1.Contains(obj))
        {
            list1.AddLast(obj);
        }
    }
}

Key Changes from the ArrayList Version: #

• Parameter Type: Swapped ArrayList for LinkedList<object> (LinkedList is a generic collection by default in .NET, which is more modern than non-generic ArrayList).
• Null Check Fix: Separated null checks to name the problematic parameter, and used logical OR (||) instead of bitwise OR (|) which was incorrect in your original code.
• Reference Check: Used ReferenceEquals() for explicit clarity when checking if both lists are the same instance.
• Add Method: Used AddLast() instead of Add()—LinkedList doesn't have a parameterless Add(), and AddLast() matches ArrayList's behavior of appending to the end.

Optimized Version (Better Performance for Large Lists) #

The basic version works, but LinkedList.Contains() runs in O(n) time (it has to traverse the entire list to find an element). For large collections, this gets slow. We can optimize using a HashSet<object> to cache existing elements, turning existence checks into O(1) time:

// Optimized merge for LinkedLists with faster deduplication
public static void MergeIntoFirstOptimized(LinkedList<object> list1, LinkedList<object> list2)
{
    if (list1 == null)
        throw new ArgumentNullException(nameof(list1));
    if (list2 == null)
        throw new ArgumentNullException(nameof(list2));
    
    if (ReferenceEquals(list1, list2))
        return;

    // Cache existing elements for instant lookups
    var existingElements = new HashSet<object>(list1);

    foreach (var obj in list2)
    {
        // HashSet.Add() returns true only if the element wasn't already present
        if (existingElements.Add(obj))
        {
            list1.AddLast(obj);
        }
    }
}

Why This Is Better: #

• We avoid redundant Contains() calls by leveraging the HashSet's built-in check-and-add logic.
• Total time complexity drops from O(n*m) (n = size of list1, m = size of list2) to O(n + m), which is a massive improvement for large lists.

Bonus: Generic Version for Type Safety #

If you want to work with specific types instead of object, a generic method prevents boxing/unboxing errors and boosts type safety:

// Generic version for type-safe LinkedList merging
public static void MergeIntoFirst<T>(LinkedList<T> list1, LinkedList<T> list2)
{
    if (list1 == null)
        throw new ArgumentNullException(nameof(list1));
    if (list2 == null)
        throw new ArgumentNullException(nameof(list2));
    
    if (ReferenceEquals(list1, list2))
        return;

    var existingElements = new HashSet<T>(list1);

    foreach (var item in list2)
    {
        if (existingElements.Add(item))
        {
            list1.AddLast(item);
        }
    }
}

This works with any LinkedList<T> (e.g., LinkedList<string>, LinkedList<int>) and keeps all the performance benefits of the optimized non-generic version.

内容的提问来源于stack exchange，提问作者Sportalcraft