La forma más rápida de comparar dos listas genéricas de diferencias

¿Cuál es el más rápido (y menos intensivo en recursos) para comparar dos masivos (> 50,000 artículos) y como resultado tener dos listas como las siguientes:

1. elementos que aparecen en la primera lista pero no en la segunda
2. elementos que aparecen en la segunda lista pero no en la primera

Actualmente estoy trabajando con List o IReadOnlyCollection y resuelvo este problema en una consulta linq:

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

Pero esto no funciona tan bien como me gustaría. ¿Alguna idea de hacer esto más rápido y menos intensivo en recursos ya que necesito procesar muchas listas?

Uso Except:

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

Sospecho que hay enfoques que en realidad serían marginalmente más rápidos que esto, pero incluso esto será mucho más rápido que su enfoque O (N * M).

Si desea combinar estos, puede crear un método con el anterior y luego una declaración de devolución:

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

Un punto a destacar es que no es una diferencia en los resultados entre el código original de la pregunta y la solución aquí: todos los elementos duplicados que son sólo en una lista sólo se informará una vez con mi código, mientras que estarían reportados como muchos veces como ocurren en el código original.

Por ejemplo, con listas de [1, 2, 2, 2, 3]y [1], los "elementos en lista1 pero no en lista2" dan como resultado el código original [2, 2, 2, 3]. Con mi código simplemente sería [2, 3]. En muchos casos eso no será un problema, pero vale la pena tenerlo en cuenta.

Más eficiente sería usar Enumerable.Except:

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

Este método se implementa mediante la ejecución diferida. Eso significa que podrías escribir, por ejemplo:

var first10 = inListButNotInList2.Take(10);

También es eficiente ya que internamente usa a Set<T>para comparar los objetos. Funciona al recopilar primero todos los valores distintos de la segunda secuencia y luego transmitir los resultados de la primera, verificando que no se hayan visto antes.

Enumerable Secuencia Método igual

Determina si dos secuencias son iguales de acuerdo con un comparador de igualdad. MS.Docs

Enumerable.SequenceEqual(list1, list2);

Esto funciona para todos los tipos de datos primitivos. Si necesita usarlo en objetos personalizados, debe implementarIEqualityComparer

Define métodos para admitir la comparación de objetos para la igualdad.

Interfaz IEqualityComparer

Define métodos para admitir la comparación de objetos para la igualdad. MS.Docs para IEqualityComparer

Si desea que los resultados no distingan entre mayúsculas y minúsculas , funcionará lo siguiente:

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

firstNotSecondcontendría b1.dll

secondNotFirstcontendría b2.dll

¡No para este problema, pero aquí hay un código para comparar listas para igual y no! objetos idénticos:

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

intenta de esta manera:

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

A veces solo necesitas saber si dos listas son diferentes, y no cuáles son esas diferencias. En ese caso, considere agregar este método de extensión a su proyecto. Tenga en cuenta que sus objetos listados deben implementar IEquatable!

Uso:

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
}

Cualquiera sea la Componentclase, los métodos que se muestran aquí paraCar deben implementarse casi de manera idéntica.

Es muy importante tener en cuenta cómo hemos escrito GetHashCode. Para implementar correctamente IEquatable, Equalsy GetHashCode debe operar en las propiedades de la instancia de una manera lógicamente compatible.

Dos listas con el mismo contenido siguen siendo objetos diferentes y producirán diferentes códigos hash. Como queremos que estas dos listas sean tratadas como iguales, debemos dejar que GetHashCodeproduzca el mismo valor para cada una de ellas. Podemos lograr esto delegando el código hash a cada elemento de la lista y usando el XOR bit a bit estándar para combinarlos a todos. XOR es independiente del orden, por lo que no importa si las listas están ordenadas de manera diferente. Solo importa que no contengan nada más que miembros equivalentes.

Nota: el nombre extraño implica el hecho de que el método no considera el orden de los elementos en la lista. Si te importa el orden de los elementos en la lista, ¡este método no es para ti!

He usado este código para comparar dos listas que tienen millones de registros.

Este método no tomará mucho tiempo.

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

Si solo se necesita un resultado combinado, esto también funcionará:

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

donde T es el tipo de elemento de listas.

Puede ser divertido, pero funciona para mí.

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

Creo que esta es una manera simple y fácil de comparar dos listas elemento por elemento

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)

Esta es la mejor solución que encontrarás

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