如何最有效地测试两个数组是不是包含 C# 中的等效项

Posted 2023-02-25

【中文标题】如何最有效地测试两个数组是不是包含 C# 中的等效项

【英文标题】：How to most efficiently test if two arrays contain equivalent items in C#如何最有效地测试两个数组是否包含 C# 中的等效项

【发布时间】：2011-10-28 12:16:41

【问题描述】：

我有两个数组，我想知道它们是否包含相同的项目。 Equals(object obj) 不起作用，因为数组是引用类型。我在下面发布了我的尝试，但由于我确定这是一项常见任务，我想知道是否有更好的测试。

    public bool ContainsEquivalentSequence<T>(T[] array1, T[] array2)
    
        bool a1IsNullOrEmpty = ReferenceEquals(array1, null) || array1.Length == 0;
        bool a2IsNullOrEmpty = ReferenceEquals(array2, null) || array2.Length == 0;
        if (a1IsNullOrEmpty) return a2IsNullOrEmpty;
        if (a2IsNullOrEmpty || array1.Length != array2.Length) return false;
        for (int i = 0; i < array1.Length; i++)
            if (!Equals(array1[i], array2[i]))
                return false;
        return true;
    

更新 - System.Linq.Enumerable.SequenceEqual 不是更好

我反映了来源，它在执行循环之前不比较长度。这是有道理的，因为该方法通常是为IEnumerable<T> 而设计的，而不是为T[] 设计的。

    public static bool SequenceEqual<TSource>(this IEnumerable<TSource> first, IEnumerable<TSource> second, IEqualityComparer<TSource> comparer)
    
        if (comparer == null)
        
            comparer = EqualityComparer<TSource>.Default;
        
        if (first == null)
        
            throw Error.ArgumentNull("first");
        
        if (second == null)
        
            throw Error.ArgumentNull("second");
        
        using (IEnumerator<TSource> enumerator = first.GetEnumerator())
        
            using (IEnumerator<TSource> enumerator2 = second.GetEnumerator())
            
                while (enumerator.MoveNext())
                
                    if (!enumerator2.MoveNext() || !comparer.Equals(enumerator.Current, enumerator2.Current))
                    
                        return false;
                    
                
                if (enumerator2.MoveNext())
                
                    return false;
                
            
        
        return true;
    

【问题讨论】：

看看LINQ Intersect()方法

@sllev: SequenceEqual 在这种情况下会更合适。

可能重复：***.com/questions/486749/…

@LukeH : 感谢您指出这一点！

您的方法名称显示为包含，但您也在检查它们是否处于相同的顺序。通常包含应该是序列不可知的。我称之为SequenceEqual。 :)

【参考方案1】：

我使用Any、Contains、All 和SequenceEqual 进行了一些测试，然后我选择了最好的 3 个。

不同的输入会有不同的结果...

两个相同的大小为 100 的数组：SequenceEqual 更快

[     SequenceEqual: 00:00:00.027   ]*
[     ContainsEqSeq: 00:00:00.046   ]
[          Parallel: 00:00:00.281   ]

两个相同的大小为 1000 的数组：SequenceEqual 更快

[     SequenceEqual: 00:00:00.240   ]*
[     ContainsEqSeq: 00:00:00.361   ]
[          Parallel: 00:00:00.491   ]

两个相同的大小为 10000 的数组：Parallel 更快

[     SequenceEqual: 00:00:02.357   ]
[     ContainsEqSeq: 00:00:03.341   ]
[          Parallel: 00:00:01.688   ]*

两个相同的大小为 50000 的数组：Parallel kick ass

[     SequenceEqual: 00:00:11.824   ]
[     ContainsEqSeq: 00:00:17.206   ]
[          Parallel: 00:00:06.811   ]*

在位置 200 处有一个差异的两个数组：SequenceEqual 更快

[     SequenceEqual: 00:00:00.050   ]*
[     ContainsEqSeq: 00:00:00.075   ]
[          Parallel: 00:00:00.332   ]

在位置 0 有一个差异的两个数组：ContainsEqSeq 和 SequenceEqual 更快

[     SequenceEqual: 00:00:00.002   ]*
[     ContainsEqSeq: 00:00:00.001   ]*
[          Parallel: 00:00:00.211   ]

在位置 999 处有一个差异的两个数组：SequenceEqual 更快

[     SequenceEqual: 00:00:00.237   ]*
[     ContainsEqSeq: 00:00:00.330   ]
[          Parallel: 00:00:00.691   ]

在位置 9999 处有一个差异的两个数组：Parallel kick ass

[     SequenceEqual: 00:00:02.386   ]
[     ContainsEqSeq: 00:00:03.417   ]
[          Parallel: 00:00:01.614   ]*

SequenceEqual 的代码是

a1.SequenceEqual(a2)

ContainsEqSeq 的代码是你的方法。

Parallel 的代码是

bool a1IsNullOrEmpty = ReferenceEquals(a1, null) || a1.Length == 0;
bool a2IsNullOrEmpty = ReferenceEquals(a2, null) || a2.Length == 0;
if (a1IsNullOrEmpty) return a2IsNullOrEmpty;
if (a2IsNullOrEmpty || a1.Length != a2.Length) return false;

var areEqual = true;
Parallel.ForEach(a1,
    (i, s, x) =>
    
        if (a1[x] != a2[x])
        
            areEqual = false;
            s.Stop();
        
    );

return areEqual;

我会说最好的取决于您的输入。

如果您将使用大型数组（例如 10000+），我会说 Parallel 是最佳选择，只有在开始时存在差异时才会输。

对于其他情况，SequenceEqual 可能是最好的，我只用int[] 进行了测试，但我相信复杂类型也可以很快。

但请记住，结果会因输入而异。

【讨论】：

Parallel 的效率因使用的系统而异，因为它使用多个内核，因为它使用多个线程，因此也要考虑到这一点。投票是因为您出于某种原因显示 OP 的代码不如该测试。 SequenceEqual 它是。