Najszybszy sposób na porównanie dwóch ogólnych list różnic

Co jest najszybsze (i najmniej wymagające zasobów) do porównania dwóch masywnych (> 50 000 pozycji), w wyniku czego mają dwie listy takie jak te poniżej:

1. elementy, które pojawiają się na pierwszej liście, ale nie na drugiej
2. elementy, które pojawiają się na drugiej liście, ale nie na pierwszej

Obecnie pracuję z List lub IReadOnlyCollection i rozwiązuję ten problem w zapytaniu linq:

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

Ale to nie działa tak dobrze, jak bym chciał. Masz pomysł, aby uczynić to szybszym i mniej wymagającym zasobów, ponieważ muszę przetworzyć wiele list?

Użyj Except:

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

Podejrzewam, że istnieją podejścia, które faktycznie byłyby nieznacznie szybsze niż to, ale nawet to będzie znacznie szybsze niż twoje podejście O (N * M).

Jeśli chcesz je połączyć, możesz utworzyć metodę z powyższym, a następnie instrukcję return:

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

Jedna uwaga jest taka, że nie ma różnicy w wynikach między oryginalnego kodu w pytaniu a tu rozwiązanie: zduplikowane elementy, które są tylko w jednej listy będą przekazywane tylko raz z mojego kodu, podczas gdy oni być zgłaszane tyle czasy występujące w oryginalnym kodzie.

Na przykład z listami [1, 2, 2, 2, 3]i [1]„elementy na liście 1, ale nie na liście 2” dają oryginalny kod [2, 2, 2, 3]. Z moim kodem byłoby po prostu [2, 3]. W wielu przypadkach nie będzie to problemem, ale warto o tym wiedzieć.

Bardziej wydajne byłoby użycie Enumerable.Except:

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

Ta metoda jest implementowana przy użyciu odroczonego wykonania. Oznacza to, że możesz napisać na przykład:

var first10 = inListButNotInList2.Take(10);

Jest również wydajny, ponieważ wewnętrznie używa a Set<T>do porównywania obiektów. Działa najpierw poprzez zebranie wszystkich różnych wartości z drugiej sekwencji, a następnie przesłanie strumieniowe wyników pierwszej, sprawdzając, czy nie były wcześniej widoczne.

Enumerable.SequenceEqual Metoda

Określa, czy dwie sekwencje są równe zgodnie z urządzeniem do porównywania równości. MS.Docs

Enumerable.SequenceEqual(list1, list2);

Działa to dla wszystkich pierwotnych typów danych. Jeśli chcesz użyć go na niestandardowych obiektach, musisz je zaimplementowaćIEqualityComparer

Definiuje metody wspomagające porównywanie obiektów pod kątem równości.

Interfejs IEqualityComparer

Definiuje metody wspomagające porównywanie obiektów pod kątem równości. MS.Docs dla IEqualityComparer

Jeśli chcesz, aby wyniki nie uwzględniały wielkości liter , następujące funkcje będą działać:

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();

firstNotSecondzawierałby b1.dll

secondNotFirstzawierałby b2.dll

Nie dla tego problemu, ale oto kod do porównania list na równe i nie! identyczne przedmioty:

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);
}

spróbuj w ten sposób:

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;
        }
    }
}

Czasami musisz tylko wiedzieć, czy dwie listy są różne, a nie jakie są te różnice. W takim przypadku rozważ dodanie tej metody rozszerzenia do swojego projektu. Zauważ, że wymienione obiekty powinny implementować IEquatable!

Stosowanie:

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
}

Niezależnie od Componentklasy, przedstawione tutaj metody Carpowinny być implementowane prawie identycznie.

Bardzo ważne jest, aby zauważyć, jak napisaliśmy GetHashCode. W celu prawidłowego wdrożenia IEquatable, Equalsi GetHashCode moszczu działać na właściwości instancji w logicznie zgodny sposób.

Dwie listy o tej samej zawartości są wciąż różnymi obiektami i będą generować różne kody skrótu. Ponieważ chcemy, aby te dwie listy były traktowane jako równe, musimy pozwolić na GetHashCodewygenerowanie tej samej wartości dla każdej z nich. Możemy to osiągnąć, delegując kod skrótu do każdego elementu na liście i używając standardowego bitowego XOR, aby połączyć je wszystkie. XOR jest niezależny od kolejności, więc nie ma znaczenia, czy listy są sortowane inaczej. Liczy się tylko to, że zawierają tylko równoważnych członków.

Uwaga: dziwna nazwa ma sugerować fakt, że metoda nie uwzględnia kolejności elementów na liście. Jeśli zależy Ci na kolejności elementów na liście, ta metoda nie jest dla Ciebie!

Użyłem tego kodu do porównania dwóch list, które mają milion rekordów.

Ta metoda nie zajmie dużo czasu

    //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;
    }

Jeśli potrzebny będzie tylko łączony wynik, to również zadziała:

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

gdzie T jest rodzajem elementu listy.

Może to jest śmieszne, ale działa dla mnie

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

Myślę, że jest to prosty i łatwy sposób na porównanie dwóch list element po elemencie

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)

To najlepsze rozwiązanie, jakie znajdziesz

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