LINQ: Determine si dos secuencias contienen exactamente los mismos elementos

Question

Necesito determinar si dos conjuntos contienen exactamente los mismos elementos. El orden no importa.

Por ejemplo, estas dos matrices deben considerarse iguales:

IEnumerable<int> data = new []{ 3,5,6,9 }; 
IEnumerable<int> otherData = new []{ 6,5,9,3} 

Un conjunto no puede contener elementos, que no están en el otro.

¿Se puede hacer esto utilizando los operadores de consulta incorporados? ¿Y cuál sería la forma más eficiente de implementarlo, teniendo en cuenta que la cantidad de elementos podría oscilar entre unos pocos y cientos?

Answer 1

Si desea tratar las matrices como "conjuntos" e ignorar el orden y duplicar los elementos, puede utilizar HashSet<T>.SetEquals method:

var isEqual = new HashSet<int>(first).SetEquals(second); 

De lo contrario, lo mejor es, probablemente, clasificando las dos secuencias de la misma manera y usando SequenceEqual para compararlos.

Answer 2

Esto debería ayudar:

IEnumerable<int> data = new []{ 3,5,6,9 }; 
    IEnumerable<int> otherData = new[] {6, 5, 9, 3}; 

    if(data.All(x => otherData.Contains(x))) 
    { 
     //Code Goes Here 
    } 

Answer 3

Si es posible que tenga duplicados (o si desea una solución que funciona mejor para las listas más largas), me gustaría probar algo como esto:

static bool IsSame<T>(IEnumerable<T> set1, IEnumerable<T> set2) 
{ 
    if (set1 == null && set2 == null) 
     return true; 
    if (set1 == null || set2 == null) 
     return false; 

    List<T> list1 = set1.ToList(); 
    List<T> list2 = set2.ToList(); 

    if (list1.Count != list2.Count) 
     return false; 

    list1.Sort(); 
    list2.Sort(); 

    return list1.SequenceEqual(list2); 
} 

ACTUALIZACIÓN: ¡Ups, tienen razón, la solución Except() a continuación debe mirar a ambos lados antes de cruzar la calle. Y tiene un rendimiento pésimo para listas más largas. Ignora la sugerencia a continuación! :-)

Aquí hay una manera fácil de hacerlo. Tenga en cuenta que esto supone que las listas no tienen duplicados.

bool same = data.Except (otherData).Count() == 0; 

Answer 4

1. En primer lugar, comprobar la longitud. Si son diferentes, los conjuntos son diferentes.
2. puede hacer data.Intersect(otherData);, y compruebe que la longitud es idéntica.
3. O bien, simplifique los conjuntos y repítelos.

Answer 5

Sugiero ordenar ambos y hacer una comparación elemento por elemento.

data.OrderBy(x => x).SequenceEqual(otherData.OrderBy(x => x)) 

no estoy seguro de la rapidez con la implementación de OrderBy es, pero si es un O (n log n) género como uno esperaría que el algoritmo total es O (n log n) también.

Para algunos casos de datos, puede mejorar esto mediante el uso de una implementación personalizada de OrderBy que, por ejemplo, utiliza una ordenación de conteo, para O (n + k), con k el tamaño del rango donde se encuentran los valores.

Answer 6

En primer lugar comprobar si las dos colecciones de datos tienen el mismo número de elementos y la comprobación de si todos los elementos en una sola colección se presentan en la otra

 IEnumerable<int> data = new[] { 3, 5, 6, 9 }; 
     IEnumerable<int> otherData = new[] { 6, 5, 9, 3 }; 

     bool equals = data.Count() == otherData.Count() && data.All(x => otherData.Contains(x)); 

Answer 7

Sé que esto es una vieja pregunta, pero aquí es otra manera para hacerlo

IEnumerable<int> data = new[] { 3, 5, 6, 9 };    
IEnumerable<int> otherData = new[] { 6, 5, 9, 3 }; 

data = data.OrderBy(d => d); 
otherData = otherData.OrderBy(d => d); 
data.Zip(otherData, (x, y) => Tuple.Create(x, y)).All(d => d.Item1 == d.Item2);