Schnellster Weg, um zwei generische Listen auf Unterschiede zu vergleichen

Was ist am schnellsten (und am wenigsten ressourcenintensiv), um zwei massive (> 50.000 Elemente) zu vergleichen und als Ergebnis zwei Listen wie die folgenden zu haben:

1. Elemente, die in der ersten Liste angezeigt werden, jedoch nicht in der zweiten
2. Elemente, die in der zweiten Liste angezeigt werden, jedoch nicht in der ersten

Derzeit arbeite ich mit der Liste oder IReadOnlyCollection und löse dieses Problem in einer Linq-Abfrage:

var list1 = list.Where(i => !list2.Contains(i)).ToList();
var list2 = list2.Where(i => !list.Contains(i)).ToList();

Aber das funktioniert nicht so gut, wie ich es gerne hätte. Haben Sie eine Idee, dies schneller und weniger ressourcenintensiv zu machen, da ich viele Listen verarbeiten muss?

Verwendung Except:

var firstNotSecond = list1.Except(list2).ToList();
var secondNotFirst = list2.Except(list1).ToList();

Ich vermute, dass es Ansätze gibt, die tatsächlich geringfügig schneller wären, aber selbst dies wird erheblich schneller sein als Ihr O (N * M) -Ansatz.

Wenn Sie diese kombinieren möchten, können Sie eine Methode mit der obigen und dann eine return-Anweisung erstellen:

return !firstNotSecond.Any() && !secondNotFirst.Any();

Ein Punkt zu beachten ist , dass es ist ein Unterschied in den Ergebnissen zwischen dem ursprünglichen Code in der Frage und die Lösung hier: alle doppelten Elemente , die nur in einer Liste sind , werden nur einmal mit meinem Code gemeldet werden, während sie so viele gemeldet werden würde Zeiten, wie sie im Originalcode vorkommen.

Beispielsweise würden bei Listen von [1, 2, 2, 2, 3]und [1]die "Elemente in Liste1, aber nicht Liste2" den ursprünglichen Code ergeben [2, 2, 2, 3]. Mit meinem Code wäre es einfach so [2, 3]. In vielen Fällen ist das kein Problem, aber es lohnt sich, sich dessen bewusst zu sein.

Effizienter wäre Enumerable.Except:

var inListButNotInList2 = list.Except(list2);
var inList2ButNotInList = list2.Except(list);

Diese Methode wird mithilfe der verzögerten Ausführung implementiert. Das heißt, Sie könnten zum Beispiel schreiben:

var first10 = inListButNotInList2.Take(10);

Es ist auch effizient, da es intern a verwendet Set<T>, um die Objekte zu vergleichen. Es funktioniert, indem zuerst alle unterschiedlichen Werte aus der zweiten Sequenz gesammelt und dann die Ergebnisse der ersten gestreamt werden, um zu überprüfen, ob sie zuvor noch nicht gesehen wurden.

Enumerable.SequenceEqual-Methode

Bestimmt, ob zwei Sequenzen gemäß einem Gleichheitsvergleich gleich sind. MS.Docs

Enumerable.SequenceEqual(list1, list2);

Dies funktioniert für alle primitiven Datentypen. Wenn Sie es für benutzerdefinierte Objekte verwenden müssen, müssen Sie es implementierenIEqualityComparer

Definiert Methoden zur Unterstützung des Vergleichs von Objekten auf Gleichheit.

IEqualityComparer-Schnittstelle

Definiert Methoden zur Unterstützung des Vergleichs von Objekten auf Gleichheit. MS.Docs für IEqualityComparer

Wenn Sie möchten, dass bei den Ergebnissen die Groß- und Kleinschreibung nicht berücksichtigt wird, funktioniert Folgendes:

List<string> list1 = new List<string> { "a.dll", "b1.dll" };
List<string> list2 = new List<string> { "A.dll", "b2.dll" };

var firstNotSecond = list1.Except(list2, StringComparer.OrdinalIgnoreCase).ToList();
var secondNotFirst = list2.Except(list1, StringComparer.OrdinalIgnoreCase).ToList();

firstNotSecondwürde b1.dll enthalten

secondNotFirstwürde b2.dll enthalten

Nicht für dieses Problem, aber hier ist ein Code zum Vergleichen von Listen für gleich und nicht! identische Objekte:

public class EquatableList<T> : List<T>, IEquatable<EquatableList<T>> where    T : IEquatable<T>

/// <summary>
/// True, if this contains element with equal property-values
/// </summary>
/// <param name="element">element of Type T</param>
/// <returns>True, if this contains element</returns>
public new Boolean Contains(T element)
{
    return this.Any(t => t.Equals(element));
}

/// <summary>
/// True, if list is equal to this
/// </summary>
/// <param name="list">list</param>
/// <returns>True, if instance equals list</returns>
public Boolean Equals(EquatableList<T> list)
{
    if (list == null) return false;
    return this.All(list.Contains) && list.All(this.Contains);
}

versuche es so:

var difList = list1.Where(a => !list2.Any(a1 => a1.id == a.id))
            .Union(list2.Where(a => !list1.Any(a1 => a1.id == a.id)));

using System.Collections.Generic;
using System.Linq;

namespace YourProject.Extensions
{
    public static class ListExtensions
    {
        public static bool SetwiseEquivalentTo<T>(this List<T> list, List<T> other)
            where T: IEquatable<T>
        {
            if (list.Except(other).Any())
                return false;
            if (other.Except(list).Any())
                return false;
            return true;
        }
    }
}

Manchmal muss man nur wissen, ob zwei Listen unterschiedlich sind und nicht, was diese Unterschiede sind. In diesem Fall sollten Sie diese Erweiterungsmethode zu Ihrem Projekt hinzufügen. Beachten Sie, dass Ihre aufgelisteten Objekte IEquatable implementieren sollten!

Verwendung:

public sealed class Car : IEquatable<Car>
{
    public Price Price { get; }
    public List<Component> Components { get; }

    ...
    public override bool Equals(object obj)
        => obj is Car other && Equals(other);

    public bool Equals(Car other)
        => Price == other.Price
            && Components.SetwiseEquivalentTo(other.Components);

    public override int GetHashCode()
        => Components.Aggregate(
            Price.GetHashCode(),
            (code, next) => code ^ next.GetHashCode()); // Bitwise XOR
}

Was auch immer die ComponentKlasse ist, die hier gezeigten Methoden fürCar nahezu identisch implementiert werden.

Es ist sehr wichtig zu beachten, wie wir GetHashCode geschrieben haben. Um richtig umzusetzen IEquatable, Equalsund GetHashCode muss auf der Instanz Eigenschaften in eine logisch kompatibelen Weise.

Zwei Listen mit demselben Inhalt sind immer noch unterschiedliche Objekte und erzeugen unterschiedliche Hash-Codes. Da diese beiden Listen gleich behandelt werden sollen, müssen wir GetHashCodefür jede Liste den gleichen Wert erzeugen. Dies können wir erreichen, indem wir den Hashcode an jedes Element in der Liste delegieren und alle mit dem standardmäßigen bitweisen XOR kombinieren. XOR ist auftragsunabhängig, daher spielt es keine Rolle, ob die Listen unterschiedlich sortiert sind. Es ist nur wichtig, dass sie nur gleichwertige Mitglieder enthalten.

Hinweis: Der seltsame Name bedeutet, dass die Methode die Reihenfolge der Elemente in der Liste nicht berücksichtigt. Wenn Sie sich für die Reihenfolge der Elemente in der Liste interessieren, ist diese Methode nichts für Sie!

Ich habe diesen Code verwendet, um zwei Listen mit Millionen von Datensätzen zu vergleichen.

Diese Methode wird nicht viel Zeit in Anspruch nehmen

    //Method to compare two list of string
    private List<string> Contains(List<string> list1, List<string> list2)
    {
        List<string> result = new List<string>();

        result.AddRange(list1.Except(list2, StringComparer.OrdinalIgnoreCase));
        result.AddRange(list2.Except(list1, StringComparer.OrdinalIgnoreCase));

        return result;
    }

Wenn nur ein kombiniertes Ergebnis benötigt wird, funktioniert dies auch:

var set1 = new HashSet<T>(list1);
var set2 = new HashSet<T>(list2);
var areEqual = set1.SetEquals(set2);

Dabei ist T der Typ des Listenelements.

Mag lustig sein, funktioniert aber für mich

string.Join ("", List1)! = string.Join ("", List2)

Ich denke, dies ist eine einfache Möglichkeit, zwei Listen Element für Element zu vergleichen

x=[1,2,3,5,4,8,7,11,12,45,96,25]
y=[2,4,5,6,8,7,88,9,6,55,44,23]

tmp = []


for i in range(len(x)) and range(len(y)):
    if x[i]>y[i]:
        tmp.append(1)
    else:
        tmp.append(0)
print(tmp)

Dies ist die beste Lösung, die Sie gefunden haben

var list3 = list1.Where(l => list2.ToList().Contains(l));