Sim, o uso do NSSet é uma abordagem sensata.
Para adicionar à resposta de Jim Puls, aqui está uma abordagem alternativa para remover duplicatas, mantendo a ordem:
// Initialise a new, empty mutable array
NSMutableArray *unique = [NSMutableArray array];
for (id obj in originalArray) {
if (![unique containsObject:obj]) {
[unique addObject:obj];
}
}
É essencialmente a mesma abordagem que a de Jim, mas copia itens exclusivos para uma nova matriz mutável, em vez de excluir duplicatas do original. Isso o torna um pouco mais eficiente de memória no caso de uma matriz grande com muitas duplicatas (não é necessário fazer uma cópia de toda a matriz) e, na minha opinião, é um pouco mais legível.
Observe que, em ambos os casos, verificar se um item já está incluído na matriz de destino (usando containsObject:no meu exemplo ouindexOfObject:inRange: no de Jim) não é adequado para grandes matrizes. Essas verificações são executadas no tempo O (N), o que significa que, se você dobrar o tamanho da matriz original, cada verificação levará o dobro do tempo para ser executada. Como você está fazendo a verificação de cada objeto na matriz, também estará executando mais dessas verificações mais caras. O algoritmo geral (tanto o meu quanto o de Jim) é executado no tempo O (N 2 ), que fica caro rapidamente à medida que a matriz original cresce.
Para reduzir o tempo O (N), você pode usar um NSMutableSet para armazenar um registro de itens já adicionados à nova matriz, pois as pesquisas do NSSet são O (1) e não O (N). Em outras palavras, verificar se um elemento é membro de um NSSet leva o mesmo tempo, independentemente de quantos elementos estiverem no conjunto.
Código usando essa abordagem seria algo como isto:
NSMutableArray *unique = [NSMutableArray array];
NSMutableSet *seen = [NSMutableSet set];
for (id obj in originalArray) {
if (![seen containsObject:obj]) {
[unique addObject:obj];
[seen addObject:obj];
}
}
Isso ainda parece um pouco inútil; ainda estamos gerando uma nova matriz quando a pergunta deixou claro que a matriz original é mutável, para que possamos redimensioná-la no local e economizar memória. Algo assim:
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++;
}
}
ATUALIZAÇÃO : Yuri Niyazov apontou que a minha última resposta na verdade é executado em O (N 2 ), porque removeObjectAtIndex:provavelmente é executado em O (N) tempo.
(Ele diz "provavelmente" porque não sabemos ao certo como é implementado; mas uma implementação possível é que, após excluir o objeto no índice X, o método percorre todos os elementos do índice X + 1 até o último objeto na matriz , movendo-os para o índice anterior. Se for esse o caso, esse é realmente o desempenho de O (N).)
Então o que fazer? Depende da situação. Se você possui uma matriz grande e espera apenas um pequeno número de duplicatas, a desduplicação no local funcionará perfeitamente e poupará a criação de uma matriz duplicada. Se você tem uma matriz em que espera muitas duplicatas, a criação de uma matriz separada e com dupagem é provavelmente a melhor abordagem. A conclusão aqui é que a notação big-O apenas descreve as características de um algoritmo, não lhe dirá definitivamente qual é o melhor para qualquer circunstância.