Sì, l'utilizzo di NSSet è un approccio sensato.
Per aggiungere alla risposta di Jim Puls, ecco un approccio alternativo per rimuovere i duplicati mantenendo l'ordine:
// Initialise a new, empty mutable array
NSMutableArray *unique = [NSMutableArray array];
for (id obj in originalArray) {
if (![unique containsObject:obj]) {
[unique addObject:obj];
}
}
È essenzialmente lo stesso approccio di Jim, ma copia elementi unici in un nuovo array mutabile piuttosto che eliminare duplicati dall'originale. Ciò rende leggermente più efficiente la memoria nel caso di un array di grandi dimensioni con molti duplicati (non è necessario eseguire una copia dell'intero array) ed è, a mio avviso, un po 'più leggibile.
Si noti che in entrambi i casi, verificando se un elemento è già incluso nell'array di destinazione (usando containsObject:nel mio esempio o indexOfObject:inRange:in quello di Jim) non si adatta bene per array di grandi dimensioni. Tali controlli vengono eseguiti nel tempo O (N), il che significa che se si raddoppia la dimensione dell'array originale, ciascun controllo richiederà il doppio del tempo per l'esecuzione. Dal momento che stai eseguendo il controllo per ogni oggetto dell'array, eseguirai anche più di quei controlli più costosi. L'algoritmo generale (sia mio che di Jim) viene eseguito nel tempo O (N 2 ), che diventa costoso rapidamente man mano che l'array originale cresce.
Per arrivare a O (N) tempo è possibile utilizzare a NSMutableSetper memorizzare un record di elementi già aggiunti al nuovo array, poiché le ricerche NSSet sono O (1) anziché O (N). In altre parole, verificare se un elemento è un membro di un NSSet richiede lo stesso tempo, indipendentemente dal numero di elementi nel set.
Il codice che utilizza questo approccio sarebbe simile al seguente:
NSMutableArray *unique = [NSMutableArray array];
NSMutableSet *seen = [NSMutableSet set];
for (id obj in originalArray) {
if (![seen containsObject:obj]) {
[unique addObject:obj];
[seen addObject:obj];
}
}
Questo sembra comunque un po 'dispendioso; stiamo ancora generando un nuovo array quando la domanda ha chiarito che l'array originale è mutabile, quindi dovremmo essere in grado di de-duplicarlo sul posto e risparmiare un po 'di memoria. Qualcosa come questo:
NSMutableSet *seen = [NSMutableSet set];
NSUInteger i = 0;
while (i < [originalArray count]) {
id obj = [originalArray objectAtIndex:i];
if ([seen containsObject:obj]) {
[originalArray removeObjectAtIndex:i];
// NB: we *don't* increment i here; since
// we've removed the object previously at
// index i, [originalArray objectAtIndex:i]
// now points to the next object in the array.
} else {
[seen addObject:obj];
i++;
}
}
AGGIORNAMENTO : Yuri Niyazov ha sottolineato che la mia ultima risposta in realtà viene eseguita in O (N 2 ) perché removeObjectAtIndex:probabilmente viene eseguita in O (N).
(Dice "probabilmente" perché non sappiamo con certezza come sia implementato, ma una possibile implementazione è che dopo aver eliminato l'oggetto all'indice X il metodo quindi scorre attraverso ogni elemento dall'indice X + 1 all'ultimo oggetto dell'array , spostandoli all'indice precedente. In tal caso, si tratta effettivamente delle prestazioni O (N).)
Quindi che si fa? Dipende dalla situazione. Se hai un array di grandi dimensioni e ti aspetti solo un numero limitato di duplicati, la de-duplicazione sul posto funzionerà perfettamente e ti farà risparmiare la creazione di un array duplicato. Se hai un array in cui ti aspetti molti duplicati, probabilmente costruire un array separato e non duplicato è probabilmente l'approccio migliore. Il take-away qui è che la notazione big-O descrive solo le caratteristiche di un algoritmo, non ti dirà definitivamente quale sia la migliore per una data circostanza.