Vergleich zweier Sammlungen auf Gleichheit unabhängig von der Reihenfolge der darin enthaltenen Elemente

Ich möchte zwei Sammlungen (in C #) vergleichen, bin mir aber nicht sicher, wie ich dies am besten effizient implementieren kann.

Ich habe den anderen Thread über Enumerable.SequenceEqual gelesen , aber es ist nicht genau das, wonach ich suche.

In meinem Fall wären zwei Sammlungen gleich, wenn beide dieselben Artikel enthalten (unabhängig von der Reihenfolge).

Beispiel:

collection1 = {1, 2, 3, 4};
collection2 = {2, 4, 1, 3};

collection1 == collection2; // true

Was ich normalerweise mache, ist, jedes Element einer Sammlung zu durchlaufen und zu prüfen, ob es in der anderen Sammlung vorhanden ist, dann jedes Element der anderen Sammlung zu durchlaufen und zu prüfen, ob es in der ersten Sammlung vorhanden ist. (Ich beginne mit dem Vergleich der Längen).

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

Dies ist jedoch nicht ganz richtig und wahrscheinlich nicht die effizienteste Methode, um zwei Sammlungen auf Gleichheit zu vergleichen.

Ein Beispiel, das ich mir vorstellen kann, wäre falsch:

collection1 = {1, 2, 3, 3, 4}
collection2 = {1, 2, 2, 3, 4}

Welches wäre gleich mit meiner Implementierung. Sollte ich nur zählen, wie oft jeder Artikel gefunden wurde, und sicherstellen, dass die Anzahl in beiden Sammlungen gleich ist?

Die Beispiele sind in einer Art C # (nennen wir es Pseudo-C #), aber geben Sie Ihre Antwort in einer beliebigen Sprache, es spielt keine Rolle.

Hinweis: Der Einfachheit halber habe ich in den Beispielen Ganzzahlen verwendet, möchte aber auch Objekte vom Referenztyp verwenden können (sie verhalten sich nicht korrekt als Schlüssel, da nur die Referenz des Objekts verglichen wird, nicht der Inhalt).

Es stellt sich heraus, dass Microsoft dies bereits in seinem Testframework behandelt hat: CollectionAssert.AreEquivalent

Bemerkungen

Zwei Sammlungen sind gleichwertig, wenn sie dieselben Elemente in derselben Menge, jedoch in beliebiger Reihenfolge enthalten. Elemente sind gleich, wenn ihre Werte gleich sind, nicht wenn sie sich auf dasselbe Objekt beziehen.

Mit Reflektor habe ich den Code hinter AreEquivalent () geändert, um einen entsprechenden Gleichheitsvergleicher zu erstellen. Es ist vollständiger als vorhandene Antworten, da es Nullen berücksichtigt, IEqualityComparer implementiert und einige Effizienz- und Randfallprüfungen aufweist. Außerdem ist es 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;
    }
}

Beispielnutzung:

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

Oder wenn Sie nur zwei Sammlungen direkt vergleichen möchten:

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

Schließlich können Sie einen Gleichstellungsvergleicher Ihrer Wahl verwenden:

var strcomp = new MultiSetComparer<string>(StringComparer.OrdinalIgnoreCase);
Console.WriteLine(strcomp.Equals(new[] {"a", "b"}, new []{"B", "A"})); //true