LINQ: Déterminer si deux séquences contiennent exactement les mêmes éléments

Question

Je dois déterminer si deux ensembles contiennent exactement les mêmes éléments. La commande n'a pas d'importance.

Par exemple, ces deux tableaux doivent être considérés comme égaux:

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

Un ensemble ne peut pas contenir des éléments, qui ne sont pas dans l'autre.

Est-ce que cela peut être fait en utilisant les opérateurs de requête intégrés? Et quel serait le moyen le plus efficace de le mettre en œuvre, étant donné que le nombre d'éléments pourrait varier de quelques-uns à des centaines?

Answer 1

Si vous voulez traiter les tableaux comme « ensembles » et d'ignorer l'ordre et dupliquer des éléments, vous pouvez utiliser HashSet<T>.SetEquals method:

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

Sinon, votre meilleur pari est probablement le tri les deux séquences de la même manière et l'utilisation SequenceEqual pour les comparer.

Answer 2

Cela devrait aider:

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 vous pourriez avoir des doublons (ou si vous voulez une solution qui fonctionne mieux pour les listes plus longues), je vais essayer quelque chose comme ceci:

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

MISE À JOUR: oups, vous avez raison, la solution Except() ci-dessous doit regarder dans les deux sens avant de traverser la rue. Et il a minable perf pour les listes plus longues. Ignorez la suggestion ci-dessous! :-)

Voici une façon simple de le faire. Notez que cela suppose que les listes n'ont pas de doublons.

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

Answer 4

1. Tout d'abord, vérifier la longueur. Si elles sont différentes, les ensembles sont différents. Vous pouvez faire data.Intersect(otherData);, et vérifiez que la longueur est identique. Ou, simplifiez le tri des ensembles et parcourez-les.

Answer 5

Je suggère de trier les deux, et de faire une comparaison élément par élément.

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

Je ne suis pas sûr à quelle vitesse la mise en œuvre de OrderBy est, mais si elle est un O (n log n) sorte que vous attendez l'algorithme total est O (n log n) ainsi. Pour certains cas de données, vous pouvez améliorer cela en utilisant une implémentation personnalisée de OrderBy qui utilise par exemple un tri de comptage, pour O (n + k), avec k la taille de la plage dans laquelle se trouvent les valeurs.

Answer 6

Vérifiez d'abord si les deux collectes de données ont le même nombre d'éléments et le contrôle si tous les éléments d'une collection sont présentés dans l'autre

 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

Je sais que c'est une vieille question, mais voici une autre façon pour le faire

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