Oui, l'utilisation de NSSet est une approche judicieuse.
Pour ajouter à la réponse de Jim Puls, voici une approche alternative pour supprimer les doublons tout en conservant l'ordre:
// Initialise a new, empty mutable array
NSMutableArray *unique = [NSMutableArray array];
for (id obj in originalArray) {
if (![unique containsObject:obj]) {
[unique addObject:obj];
}
}
C'est essentiellement la même approche que celle de Jim, mais copie les éléments uniques dans un nouveau tableau mutable plutôt que de supprimer les doublons de l'original. Cela le rend légèrement plus efficace dans le cas d'un grand tableau avec beaucoup de doublons (pas besoin de faire une copie de l'ensemble du tableau), et est à mon avis un peu plus lisible.
Notez que dans les deux cas, vérifier si un élément est déjà inclus dans le tableau cible (en utilisant containsObject:dans mon exemple, ou indexOfObject:inRange:dans celui de Jim) ne s'adapte pas bien aux grands tableaux. Ces vérifications s'exécutent en temps O (N), ce qui signifie que si vous doublez la taille du tableau d'origine, chaque vérification prendra deux fois plus de temps à s'exécuter. Puisque vous effectuez la vérification pour chaque objet du tableau, vous exécuterez également plus de ces vérifications plus coûteuses. L'algorithme global (le mien et celui de Jim) s'exécute en temps O (N 2 ), ce qui devient vite coûteux à mesure que le tableau d'origine se développe.
Pour ramener cela au temps O (N), vous pouvez utiliser a NSMutableSetpour stocker un enregistrement des éléments déjà ajoutés au nouveau tableau, car les recherches NSSet sont O (1) plutôt que O (N). En d'autres termes, vérifier si un élément est membre d'un NSSet prend le même temps, quel que soit le nombre d'éléments dans l'ensemble.
Le code utilisant cette approche ressemblerait à ceci:
NSMutableArray *unique = [NSMutableArray array];
NSMutableSet *seen = [NSMutableSet set];
for (id obj in originalArray) {
if (![seen containsObject:obj]) {
[unique addObject:obj];
[seen addObject:obj];
}
}
Cela semble néanmoins un peu inutile; nous sommes toujours en train de générer un nouveau tableau lorsque la question a clairement indiqué que le tableau d'origine est mutable, nous devrions donc être en mesure de le déduper en place et d'économiser de la mémoire. Quelque chose comme ça:
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++;
}
}
MISE À JOUR : Yuri Niyazov a souligné que ma dernière réponse s'exécute en fait en O (N 2 ) parce que removeObjectAtIndex:probablement en O (N).
(Il dit "probablement" parce que nous ne savons pas avec certitude comment il est implémenté; mais une implémentation possible est qu'après avoir supprimé l'objet à l'index X, la méthode boucle ensuite sur chaque élément de l'index X + 1 au dernier objet du tableau , en les déplaçant vers l'index précédent. Si tel est le cas, il s'agit bien de la performance O (N).)
Alors que faire? Ça dépend de la situation. Si vous avez un grand tableau et que vous ne vous attendez qu'à un petit nombre de doublons, la déduplication sur place fonctionnera très bien et vous évitera d'avoir à créer un tableau en double. Si vous avez un tableau dans lequel vous vous attendez à beaucoup de doublons, la création d'un tableau séparé et déduppé est probablement la meilleure approche. Ce qu'il faut retenir ici, c'est que la notation big-O ne décrit que les caractéristiques d'un algorithme, elle ne vous dira pas définitivement ce qui est le mieux pour une circonstance donnée.