什么是确定两个列表的最佳方法 <T> 对象包含相同的值集，即使它们的顺序不同？ [重复]

Question

这个问题已经在这里有了答案：

• 比较两个List <T>对象是否相等，忽略顺序[重复] 9个答案

我有两个List<T>对象（其中T是两个对象的相同类型），并且我需要能够确定它们是否包含相同的一组值，即使这些值的顺序不同。

这些对象是否具有内置机制来完成此任务，还是需要编写自己的算法？

或者，也许我应该使用其他类型的集合，而不是List<T> ？

如果我要编写自己的算法，则可能包含以下步骤-如果我遵循以下路线，我将尝试在最终版本中对其进行优化：

• 两个集合是否包含相同数量的值？ 如果没有返回false。
• 计算每个值在每个集合中出现的次数，如果计数不相等，则返回false。
• 如果我到达两个集合的末尾而值计数没有任何不相等，则返回true。

我知道对此有一些警告，例如T必须具有可比性这一事实-我现在使用默认比较（例如.Equals() ），并为泛型类型定义了适当的约束。

Answer 1

根据现有信息，我怀疑支持重复的最有效解决方案是

• 比较两个列表的大小。 如果不相等，则返回false。 如果相等
• 对两个列表进行排序。 如果您必须保留原始列表的顺序，请对列表的副本进行排序。
• 比较排序列表中每个位置的元素，如果给定位置的值不相等，则返回false。 如果您比较了所有元素但没有发现差异，则返回true。

请注意，我已经假设在此操作期间有足够的内存来创建列表的排序副本（应保留顺序）。

Answer 2

因此，我们将从一个简单的SetEquals ，然后从那里开始。 HashSet已经有这样一种方法的实现，该方法可以比较两个集合是否相等，因此我们可以围绕它创建一个包装器，以便可以将其与任何类型的序列一起使用：

public static bool SetEquals<T>(this IEnumerable<T> first, IEnumerable<T> second,
    IEqualityComparer<T> comparer = null)
{
    return new HashSet<T>(second, comparer ?? EqualityComparer<T>.Default)
        .SetEquals(first);
}

接下来，要考虑到您有一个手提袋而不是一套，我们只需要取下您拥有的两个序列，将它们分组，然后将其投影成对，就可以算出该项目以及匹配项目的数量。 如果我们对两个集合都这样做，那么我们可以将这些对象序列作为集合进行比较 ，看看它们是否相等。 如果键计数对序列都是集合相等的，则原始序列是袋相等的：

public static bool BagEquals<T>(
    this IEnumerable<T> first,
    IEnumerable<T> second)
{
    Func<IEnumerable<T>, IEnumerable<KeyValuePair<T, int>>> groupItems =
        sequence => sequence.GroupBy(item => item,
            (key, items) => new KeyValuePair<T, int>(key, items.Count()));
    return groupItems(first)
        .SetEquals(groupItems(second));
}

Answer 3

这是CollectionAssert.AreEquivalent的重新实现（参考代码已用DotPeek进行反编译），但是它没有抛出异常，而是返回了布尔值。

public class CollectionMethods
{
    public static bool AreEquivalent(ICollection expected, ICollection actual)
    {
        //We can do a few quick tests we can do to get a easy true or easy false.
        //Is one collection null and one not?
        if (Object.ReferenceEquals(expected, null) != Object.ReferenceEquals(actual, null))
            return false;

        //Do they both point at the same object?
        if (Object.ReferenceEquals(expected, actual))
            return true;

        //Do they have diffrent counts?
        if (expected.Count != actual.Count)
            return false;

        //Do we have two empty collections?
        if (expected.Count == 0)
            return true;


        //Ran out of easy tests, now have to do the slow work.
        int nullCount1;
        Dictionary<object, int> elementCounts1 = CollectionMethods.GetElementCounts(expected, out nullCount1);
        int nullCount2;
        Dictionary<object, int> elementCounts2 = CollectionMethods.GetElementCounts(actual, out nullCount2);

        //One last quick check, do the two collections have the same number of null elements?
        if (nullCount2 != nullCount1)
        {
            return false;
        }

        //Check for each element and see if we see them the same number of times in both collections.
        foreach (KeyValuePair<object,int> kvp in elementCounts1)
        {
            int expectedCount = kvp.Value;
            int actualCount;
            elementCounts2.TryGetValue(key, out actualCount);
            if (expectedCount != actualCount)
            {
                return false;
            }
        }
        return true;
    }

    private static Dictionary<object, int> GetElementCounts(ICollection collection, out int nullCount)
    {
        Dictionary<object, int> dictionary = new Dictionary<object, int>();
        nullCount = 0;
        foreach (object key in (IEnumerable)collection)
        {
            if (key == null)
            {
                ++nullCount;
            }
            else
            {
                int num;
                dictionary.TryGetValue(key, out num);
                ++num;
                dictionary[key] = num;
            }
        }
        return dictionary;
    }
}