LINQ: Determina se due sequenze contengono esattamente gli stessi elementi

Question

Devo determinare se due set contengono esattamente gli stessi elementi. L'ordine non ha importanza.

Ad esempio, i due array deve essere considerato uguale:

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

Un set non può contenere elementi, che non sono altro.

È possibile farlo utilizzando gli operatori di query incorporati? E quale sarebbe il modo più efficace per implementarlo, considerando che il numero di elementi potrebbe variare da poche a centinaia?

Answer 1

Se si desidera trattare gli array come "set" e l'ordine ignorare e duplicare gli oggetti, è possibile utilizzare HashSet<T>.SetEquals method:

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

In caso contrario, la soluzione migliore è probabilmente ordinamento entrambe le sequenze nello stesso modo e utilizzando SequenceEqual per confrontarli.

Answer 2

Questo dovrebbe aiutare:

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

Se si potrebbe avere duplicati (o se si desidera una soluzione che funziona meglio per gli elenchi più lunghi), mi piacerebbe provare qualcosa di simile:

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

AGGIORNAMENTO: oops, voi ragazzi avete ragione-- la soluzione Except() qui sotto deve guardare in entrambe le direzioni prima di attraversare la strada. E ha pessimo perf per liste più lunghe. Ignora il suggerimento qui sotto! :-)

Ecco un modo semplice per farlo. Si noti che questo presuppone che gli elenchi non abbiano duplicati.

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

Answer 4

1. In primo luogo, verificare la lunghezza. Se sono diversi, gli insiemi sono diversi.
2. è possibile eseguire data.Intersect(otherData); e verificare che la lunghezza sia identica.
3. OPPURE, semplifica l'ordinamento dei set e scorre iterarli.

Answer 5

Suggerisco di ordinare entrambi e di eseguire un confronto elemento per elemento.

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

non sono sicuro quanto velocemente l'attuazione di OrderBy è, ma se è un O (n log n) sorta come ci si aspetterebbe l'algoritmo totale è O (n log n) pure.

Per alcuni casi di dati, è possibile migliorare su questo utilizzando un'implementazione personalizzata di OrderBy che ad esempio utilizza un ordinamento di conteggio, per O (n + k), con k la dimensione dell'intervallo in cui si trovano i valori.

Answer 6

In primo luogo verificare se entrambe le raccolte di dati hanno lo stesso numero di elementi ed il controllo se tutti gli elementi di una collezione sono presentati negli altri

 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

So che questa è una vecchia questione, ma qui è un altro modo per farlo

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