我想比较两个集合（在C＃中），但我不确定有效实现它的最佳方法。
我已经阅读了关于Enumerable.SequenceEqual的其他帖子，但这并不是我正在寻找的。
在我的情况下，如果两个集合都包含相同的项目（无论顺序如何），它们将是相同的。
示例：
collection1 = {1, 2, 3, 4};
collection2 = {2, 4, 1, 3};
collection1 == collection2; // true
我通常做的是遍历一个集合中的每个项目，看看它是否存在于另一个集合中，然后循环遍历另一个集合的每个项目，看看它是否存在于第一个集合中。 （我首先比较长度）。
if (collection1.Count != collection2.Count)
return false; // the collections are not equal
foreach (Item item in collection1)
{
if (!collection2.Contains(item))
return false; // the collections are not equal
}
foreach (Item item in collection2)
{
if (!collection1.Contains(item))
return false; // the collections are not equal
}
return true; // the collections are equal
然而，这并不完全正确，并且它可能不是比较两个集合的最有效方法。
我能想到的一个例子是错误的：
collection1 = {1, 2, 3, 3, 4}
collection2 = {1, 2, 2, 3, 4}
这与我的实施相同。我应该只计算每个项目的找到次数，并确保两个馆藏中的计数相等吗？
这些例子在某种C＃中（我们称之为伪C＃），但是用你想要的任何语言给出你的答案，这没关系。
注意：为简单起见，我在示例中使用了整数，但我希望能够使用引用类型对象（它们的行为不正确，因为只有对象的引用是比较，而不是内容）。
答案 0 :(得分：106)
事实证明，微软已经在其测试框架中涵盖了这一点：CollectionAssert.AreEquivalent
说明
如果他们是两个集合是等价的 具有相同的元素 数量，但以任何顺序。分子 如果他们的价值相等，则相等， 如果他们引用相同的对象，则不会。
使用反射器，我修改了AreEquivalent（）背后的代码，以创建相应的相等比较器。它比现有的答案更完整，因为它考虑了空值，实现IEqualityComparer并具有一些效率和边缘案例检查。另外，它是 Microsoft ：）
public class MultiSetComparer<T> : IEqualityComparer<IEnumerable<T>>
{
private readonly IEqualityComparer<T> m_comparer;
public MultiSetComparer(IEqualityComparer<T> comparer = null)
{
m_comparer = comparer ?? EqualityComparer<T>.Default;
}
public bool Equals(IEnumerable<T> first, IEnumerable<T> second)
{
if (first == null)
return second == null;
if (second == null)
return false;
if (ReferenceEquals(first, second))
return true;
if (first is ICollection<T> firstCollection && second is ICollection<T> secondCollection)
{
if (firstCollection.Count != secondCollection.Count)
return false;
if (firstCollection.Count == 0)
return true;
}
return !HaveMismatchedElement(first, second);
}
private bool HaveMismatchedElement(IEnumerable<T> first, IEnumerable<T> second)
{
int firstNullCount;
int secondNullCount;
var firstElementCounts = GetElementCounts(first, out firstNullCount);
var secondElementCounts = GetElementCounts(second, out secondNullCount);
if (firstNullCount != secondNullCount || firstElementCounts.Count != secondElementCounts.Count)
return true;
foreach (var kvp in firstElementCounts)
{
var firstElementCount = kvp.Value;
int secondElementCount;
secondElementCounts.TryGetValue(kvp.Key, out secondElementCount);
if (firstElementCount != secondElementCount)
return true;
}
return false;
}
private Dictionary<T, int> GetElementCounts(IEnumerable<T> enumerable, out int nullCount)
{
var dictionary = new Dictionary<T, int>(m_comparer);
nullCount = 0;
foreach (T element in enumerable)
{
if (element == null)
{
nullCount++;
}
else
{
int num;
dictionary.TryGetValue(element, out num);
num++;
dictionary[element] = num;
}
}
return dictionary;
}
public int GetHashCode(IEnumerable<T> enumerable)
{
if (enumerable == null) throw new ArgumentNullException(nameof(enumerable));
int hash = 17;
foreach (T val in enumerable.OrderBy(x => x))
hash = hash * 23 + (val?.GetHashCode() ?? 42);
return hash;
}
}
样本用法：
var set = new HashSet<IEnumerable<int>>(new[] {new[]{1,2,3}}, new MultiSetComparer<int>());
Console.WriteLine(set.Contains(new [] {3,2,1})); //true
Console.WriteLine(set.Contains(new [] {1, 2, 3, 3})); //false
或者，如果您只是想直接比较两个集合：
var comp = new MultiSetComparer<string>();
Console.WriteLine(comp.Equals(new[] {"a","b","c"}, new[] {"a","c","b"})); //true
Console.WriteLine(comp.Equals(new[] {"a","b","c"}, new[] {"a","b"})); //false
最后，您可以使用您选择的相等比较器：
var strcomp = new MultiSetComparer<string>(StringComparer.OrdinalIgnoreCase);
Console.WriteLine(strcomp.Equals(new[] {"a", "b"}, new []{"B", "A"})); //true
答案 1 :(得分：90)
一个简单而有效的解决方案是对两个集合进行排序，然后将它们进行相等性比较：
bool equal = collection1.OrderBy(i => i).SequenceEqual(
collection2.OrderBy(i => i));
此算法为O（N * logN），而您的解决方案为O（N ^ 2）。
如果集合具有某些属性，您可以实现更快的解决方案。例如，如果两个集合都是哈希集，则它们不能包含重复项。此外，检查哈希集是否包含某个元素非常快。在这种情况下，类似于你的算法可能会最快。
答案 2 :(得分：31)
创建一个字典“dict”，然后对第一个集合中的每个成员，执行dict [member] ++;
然后，以相同的方式遍历第二个集合，但是对于每个成员，请执行[member] - 。
最后，循环遍历字典中的所有成员：
private bool SetEqual (List<int> left, List<int> right) {
if (left.Count != right.Count)
return false;
Dictionary<int, int> dict = new Dictionary<int, int>();
foreach (int member in left) {
if (dict.ContainsKey(member) == false)
dict[member] = 1;
else
dict[member]++;
}
foreach (int member in right) {
if (dict.ContainsKey(member) == false)
return false;
else
dict[member]--;
}
foreach (KeyValuePair<int, int> kvp in dict) {
if (kvp.Value != 0)
return false;
}
return true;
}
编辑：据我所知，这与最有效的算法顺序相同。该算法为O（N），假设字典使用O（1）查找。
答案 3 :(得分：18)
这是我（受D.Jennings影响很大）比较方法的通用实现（在C＃中）：
/// <summary>
/// Represents a service used to compare two collections for equality.
/// </summary>
/// <typeparam name="T">The type of the items in the collections.</typeparam>
public class CollectionComparer<T>
{
/// <summary>
/// Compares the content of two collections for equality.
/// </summary>
/// <param name="foo">The first collection.</param>
/// <param name="bar">The second collection.</param>
/// <returns>True if both collections have the same content, false otherwise.</returns>
public bool Execute(ICollection<T> foo, ICollection<T> bar)
{
// Declare a dictionary to count the occurence of the items in the collection
Dictionary<T, int> itemCounts = new Dictionary<T,int>();
// Increase the count for each occurence of the item in the first collection
foreach (T item in foo)
{
if (itemCounts.ContainsKey(item))
{
itemCounts[item]++;
}
else
{
itemCounts[item] = 1;
}
}
// Wrap the keys in a searchable list
List<T> keys = new List<T>(itemCounts.Keys);
// Decrease the count for each occurence of the item in the second collection
foreach (T item in bar)
{
// Try to find a key for the item
// The keys of a dictionary are compared by reference, so we have to
// find the original key that is equivalent to the "item"
// You may want to override ".Equals" to define what it means for
// two "T" objects to be equal
T key = keys.Find(
delegate(T listKey)
{
return listKey.Equals(item);
});
// Check if a key was found
if(key != null)
{
itemCounts[key]--;
}
else
{
// There was no occurence of this item in the first collection, thus the collections are not equal
return false;
}
}
// The count of each item should be 0 if the contents of the collections are equal
foreach (int value in itemCounts.Values)
{
if (value != 0)
{
return false;
}
}
// The collections are equal
return true;
}
}
答案 4 :(得分：10)
答案 5 :(得分：5)
编辑：我意识到，一旦我提出这真的只适用于集合 - 它将无法正确处理具有重复项目的集合。例如，从该算法的角度来看，{1,1,2}和{2,2,1}将被认为是相等的。但是，如果您的集合是集合（或者它们的相等性可以这样衡量），我希望您能找到以下有用的集合。
我使用的解决方案是：
return c1.Count == c2.Count && c1.Intersect(c2).Count() == c1.Count;
Linq做了字典下的事情，所以这也是O（N）。 （注意，如果集合的大小不同，则为O（1）。）
我使用Daniel建议的“SetEqual”方法，Igor建议的OrderBy / SequenceEquals方法以及我的建议进行了健全性检查。结果如下，显示Igor的O（N * LogN）和我和Daniel的O（N）。
我认为Linq交叉代码的简单性使其成为首选解决方案。
__Test Latency(ms)__
N, SetEquals, OrderBy, Intersect
1024, 0, 0, 0
2048, 0, 0, 0
4096, 31.2468, 0, 0
8192, 62.4936, 0, 0
16384, 156.234, 15.6234, 0
32768, 312.468, 15.6234, 46.8702
65536, 640.5594, 46.8702, 31.2468
131072, 1312.3656, 93.7404, 203.1042
262144, 3765.2394, 187.4808, 187.4808
524288, 5718.1644, 374.9616, 406.2084
1048576, 11420.7054, 734.2998, 718.6764
2097152, 35090.1564, 1515.4698, 1484.223
答案 6 :(得分：5)
如果没有重复且没有顺序，则可以使用以下EqualityComparer将集合作为字典键：
public class SetComparer<T> : IEqualityComparer<IEnumerable<T>>
where T:IComparable<T>
{
public bool Equals(IEnumerable<T> first, IEnumerable<T> second)
{
if (first == second)
return true;
if ((first == null) || (second == null))
return false;
return first.ToHashSet().SetEquals(second);
}
public int GetHashCode(IEnumerable<T> enumerable)
{
int hash = 17;
foreach (T val in enumerable.OrderBy(x => x))
hash = hash * 23 + val.GetHashCode();
return hash;
}
}
Here是我使用的ToHashSet（）实现。 hash code algorithm来自Effective Java（通过Jon Skeet）。
答案 7 :(得分：4)
static bool SetsContainSameElements<T>(IEnumerable<T> set1, IEnumerable<T> set2) {
var setXOR = new HashSet<T>(set1);
setXOR.SymmetricExceptWith(set2);
return (setXOR.Count == 0);
}
解决方案需要.NET 3.5和System.Collections.Generic命名空间。 According to Microsoft，SymmetricExceptWith是 O（n + m）操作， n 表示第一组中的元素数量 m 表示第二个元素的数量。如有必要，您可以随时向此函数添加相等比较器。
答案 8 :(得分：3)
如果您使用Shouldly，则可以将ShouldAllBe与Contains一起使用。
collection1 = {1, 2, 3, 4};
collection2 = {2, 4, 1, 3};
collection1.ShouldAllBe(item=>collection2.Contains(item)); // true
最后，你可以写一个扩展名。
public static class ShouldlyIEnumerableExtensions
{
public static void ShouldEquivalentTo<T>(this IEnumerable<T> list, IEnumerable<T> equivalent)
{
list.ShouldAllBe(l => equivalent.Contains(l));
}
}
<强>更新
ShouldBe 方法中存在可选参数。
collection1.ShouldBe(collection2, ignoreOrder: true); // true
答案 9 :(得分：3)
为什么不使用.Except（）
// Create the IEnumerable data sources.
string[] names1 = System.IO.File.ReadAllLines(@"../../../names1.txt");
string[] names2 = System.IO.File.ReadAllLines(@"../../../names2.txt");
// Create the query. Note that method syntax must be used here.
IEnumerable<string> differenceQuery = names1.Except(names2);
// Execute the query.
Console.WriteLine("The following lines are in names1.txt but not names2.txt");
foreach (string s in differenceQuery)
Console.WriteLine(s);
答案 10 :(得分：2)
重复的帖子，但是check out my solution for comparing collections。这很简单：
无论顺序如何，这都将执行相等比较：
var list1 = new[] { "Bill", "Bob", "Sally" };
var list2 = new[] { "Bob", "Bill", "Sally" };
bool isequal = list1.Compare(list2).IsSame;
这将检查项目是否已添加/删除：
var list1 = new[] { "Billy", "Bob" };
var list2 = new[] { "Bob", "Sally" };
var diff = list1.Compare(list2);
var onlyinlist1 = diff.Removed; //Billy
var onlyinlist2 = diff.Added; //Sally
var inbothlists = diff.Equal; //Bob
这将看到字典中的哪些项目发生了变化：
var original = new Dictionary<int, string>() { { 1, "a" }, { 2, "b" } };
var changed = new Dictionary<int, string>() { { 1, "aaa" }, { 2, "b" } };
var diff = original.Compare(changed, (x, y) => x.Value == y.Value, (x, y) => x.Value == y.Value);
foreach (var item in diff.Different)
Console.Write("{0} changed to {1}", item.Key.Value, item.Value.Value);
//Will output: a changed to aaa
原帖[{3}}。
答案 11 :(得分：1)
erickson几乎是正确的：因为您想要匹配重复次数，所以需要Bag。在Java中，这看起来像：
(new HashBag(collection1)).equals(new HashBag(collection2))
我确信C＃有一个内置的Set实现。我先用它;如果性能有问题，您可以始终使用不同的Set实现，但使用相同的Set接口。
答案 12 :(得分：1)
这是一个比this one改进的解决方案。
public static bool HasSameElementsAs<T>(
this IEnumerable<T> first,
IEnumerable<T> second,
IEqualityComparer<T> comparer = null)
{
var firstMap = first
.GroupBy(x => x, comparer)
.ToDictionary(x => x.Key, x => x.Count(), comparer);
var secondMap = second
.GroupBy(x => x, comparer)
.ToDictionary(x => x.Key, x => x.Count(), comparer);
if (firstMap.Keys.Count != secondMap.Keys.Count)
return false;
if (firstMap.Keys.Any(k1 => !secondMap.ContainsKey(k1)))
return false;
return firstMap.Keys.All(x => firstMap[x] == secondMap[x]);
}
答案 13 :(得分：1)
这是ohadsc答案的扩展方法变体，以防它对某人有用
static public class EnumerableExtensions
{
static public bool IsEquivalentTo<T>(this IEnumerable<T> first, IEnumerable<T> second)
{
if ((first == null) != (second == null))
return false;
if (!object.ReferenceEquals(first, second) && (first != null))
{
if (first.Count() != second.Count())
return false;
if ((first.Count() != 0) && HaveMismatchedElement<T>(first, second))
return false;
}
return true;
}
private static bool HaveMismatchedElement<T>(IEnumerable<T> first, IEnumerable<T> second)
{
int firstCount;
int secondCount;
var firstElementCounts = GetElementCounts<T>(first, out firstCount);
var secondElementCounts = GetElementCounts<T>(second, out secondCount);
if (firstCount != secondCount)
return true;
foreach (var kvp in firstElementCounts)
{
firstCount = kvp.Value;
secondElementCounts.TryGetValue(kvp.Key, out secondCount);
if (firstCount != secondCount)
return true;
}
return false;
}
private static Dictionary<T, int> GetElementCounts<T>(IEnumerable<T> enumerable, out int nullCount)
{
var dictionary = new Dictionary<T, int>();
nullCount = 0;
foreach (T element in enumerable)
{
if (element == null)
{
nullCount++;
}
else
{
int num;
dictionary.TryGetValue(element, out num);
num++;
dictionary[element] = num;
}
}
return dictionary;
}
static private int GetHashCode<T>(IEnumerable<T> enumerable)
{
int hash = 17;
foreach (T val in enumerable.OrderBy(x => x))
hash = hash * 23 + val.GetHashCode();
return hash;
}
}
答案 14 :(得分：0)
在许多情况下，唯一合适的答案是Igor Ostrovsky，其他答案都是基于对象哈希码。 但是，当您为对象生成哈希代码时，只能基于其IMMUTABLE字段 - 例如对象ID字段（如果是数据库实体） - Why is it important to override GetHashCode when Equals method is overridden?
这意味着，如果比较两个集合，即使不同项的字段不相等，结果也可能与compare方法一致。 要深入比较集合，您需要使用Igor的方法并实现IEqualirity。
请在他投票最多的帖子上阅读我和施奈德先生的评论。
詹姆斯
答案 15 :(得分：0)
这个问题有很多解决方案。 如果您不关心重复项，则不必对两者进行排序。首先确保它们具有相同数量的项目。之后排序其中一个集合。然后bin搜索已排序集合中第二个集合中的每个项目。如果没有找到给定的项目停止并返回false。 这种复杂性： - 排序第一个集合：N Log（N） - 从第二个搜索每个项目到第一个：N LOG（N） 所以你最终得到2 * N * LOG（N）假设它们匹配并且你查找一切。这类似于排序两者的复杂性。如果存在差异，这也可以让您早点停下来。 但是，请记住，如果在您进入此比较之前对两者进行排序，并且您尝试使用类似qsort的排序，则排序将更加昂贵。对此有优化。 另一种替代方案，对于您知道元素范围的小型集合来说非常有用，就是使用位掩码索引。这将为您提供O（n）性能。 另一种方法是使用哈希并查找它。对于小型集合，进行排序或位掩码索引通常要好得多。 Hashtable具有较差的局部性的缺点，因此请牢记这一点。 同样，只有在你不关心重复时才会这样。如果你想考虑重复，请选择排序。
答案 16 :(得分：0)
允许在IEnumerable<T>中重复（如果不希望使用组），并且可以“忽略顺序”，那么您应该可以使用.GroupBy()。
我不是复杂度测量方面的专家，但是我的基本理解是这应该是O（n）。我将O（n ^ 2）理解为是在另一个ListA.Where(a => ListB.Contains(a)).ToList()之类的O（n）操作中执行O（n）操作而来的。评估ListB中的每个项目是否与ListA中的每个项目相等。
就像我说的那样，我对复杂性的理解是有限的，因此如果我错了，请对此进行纠正。
public static bool IsSameAs<T, TKey>(this IEnumerable<T> source, IEnumerable<T> target, Expression<Func<T, TKey>> keySelectorExpression)
{
// check the object
if (source == null && target == null) return true;
if (source == null || target == null) return false;
var sourceList = source.ToList();
var targetList = target.ToList();
// check the list count :: { 1,1,1 } != { 1,1,1,1 }
if (sourceList.Count != targetList.Count) return false;
var keySelector = keySelectorExpression.Compile();
var groupedSourceList = sourceList.GroupBy(keySelector).ToList();
var groupedTargetList = targetList.GroupBy(keySelector).ToList();
// check that the number of grouptings match :: { 1,1,2,3,4 } != { 1,1,2,3,4,5 }
var groupCountIsSame = groupedSourceList.Count == groupedTargetList.Count;
if (!groupCountIsSame) return false;
// check that the count of each group in source has the same count in target :: for values { 1,1,2,3,4 } & { 1,1,1,2,3,4 }
// key:count
// { 1:2, 2:1, 3:1, 4:1 } != { 1:3, 2:1, 3:1, 4:1 }
var countsMissmatch = groupedSourceList.Any(sourceGroup =>
{
var targetGroup = groupedTargetList.Single(y => y.Key.Equals(sourceGroup.Key));
return sourceGroup.Count() != targetGroup.Count();
});
return !countsMissmatch;
}
答案 17 :(得分：0)
This simple solution强制IEnumerable的通用类型实现IComparable。因为
OrderBy的定义。
如果您不想做这样的假设，但仍然想使用此解决方案，则可以使用以下代码：
bool equal = collection1.OrderBy(i => i?.GetHashCode())
.SequenceEqual(collection2.OrderBy(i => i?.GetHashCode()));
答案 18 :(得分：0)
如果出于单元测试断言的目的进行比较，则可以在进行比较之前将一些效率提高到窗口之外并简单地将每个列表转换为字符串表示形式（csv），这可能是有意义的。这样，默认的测试断言消息将在错误消息中显示差异。
用法：
using Microsoft.VisualStudio.TestTools.UnitTesting;
// define collection1, collection2, ...
Assert.Equal(collection1.OrderBy(c=>c).ToCsv(), collection2.OrderBy(c=>c).ToCsv());
Helper扩展方法：
public static string ToCsv<T>(
this IEnumerable<T> values,
Func<T, string> selector,
string joinSeparator = ",")
{
if (selector == null)
{
if (typeof(T) == typeof(Int16) ||
typeof(T) == typeof(Int32) ||
typeof(T) == typeof(Int64))
{
selector = (v) => Convert.ToInt64(v).ToStringInvariant();
}
else if (typeof(T) == typeof(decimal))
{
selector = (v) => Convert.ToDecimal(v).ToStringInvariant();
}
else if (typeof(T) == typeof(float) ||
typeof(T) == typeof(double))
{
selector = (v) => Convert.ToDouble(v).ToString(CultureInfo.InvariantCulture);
}
else
{
selector = (v) => v.ToString();
}
}
return String.Join(joinSeparator, values.Select(v => selector(v)));
}
答案 19 :(得分：0)
基于这个重复问题的 answer 和答案下方的评论，以及 @brian-genisio answer 我想出了这些：
public static bool AreEquivalentIgnoringDuplicates<T>(this IEnumerable<T> items, IEnumerable<T> otherItems)
{
var itemList = items.ToList();
var otherItemList = otherItems.ToList();
var except = itemList.Except(otherItemList);
return itemList.Count == otherItemList.Count && except.IsEmpty();
}
public static bool AreEquivalent<T>(this IEnumerable<T> items, IEnumerable<T> otherItems)
{
var itemList = items.ToList();
var otherItemList = otherItems.ToList();
var except = itemList.Except(otherItemList);
return itemList.Distinct().Count() == otherItemList.Count && except.IsEmpty();
}
测试这两个：
[Test]
public void collection_with_duplicates_are_equivalent()
{
var a = new[] {1, 5, 5};
var b = new[] {1, 1, 5};
a.AreEquivalentIgnoringDuplicates(b).ShouldBe(true);
}
[Test]
public void collection_with_duplicates_are_not_equivalent()
{
var a = new[] {1, 5, 5};
var b = new[] {1, 1, 5};
a.AreEquivalent(b).ShouldBe(false);
}