Да, использование NSSet - разумный подход.
Чтобы добавить к ответу Джима Пулса, вот альтернативный подход к удалению дубликатов при сохранении порядка:
// Initialise a new, empty mutable array
NSMutableArray *unique = [NSMutableArray array];
for (id obj in originalArray) {
if (![unique containsObject:obj]) {
[unique addObject:obj];
}
}
По сути, это тот же подход, что и у Джима, но он копирует уникальные элементы в новый изменяемый массив, а не удаляет дубликаты из оригинала. Это делает его немного более эффективным в отношении памяти в случае большого массива с большим количеством дубликатов (не нужно делать копию всего массива) и, на мой взгляд, немного более читабельным.
Обратите внимание, что в любом случае проверка того, включен ли элемент в целевой массив (используется containsObject:в моем примере или indexOfObject:inRange:в Jim's), плохо масштабируется для больших массивов. Эти проверки выполняются за время O (N), что означает, что если вы удвоите размер исходного массива, то для каждой проверки потребуется вдвое больше времени. Так как вы делаете проверку для каждого объекта в массиве, вы также будете выполнять больше этих более дорогих проверок. Общий алгоритм (как мой, так и Джима) выполняется за время O (N 2 ), что быстро растет с ростом исходного массива.
Чтобы получить это время O (N), вы можете использовать a NSMutableSetдля хранения записи элементов, уже добавленных в новый массив, так как NSSet ищет O (1), а не O (N). Другими словами, проверка того, является ли элемент членом NSSet, занимает одно и то же время, независимо от того, сколько элементов в наборе.
Код, использующий этот подход, будет выглядеть примерно так:
NSMutableArray *unique = [NSMutableArray array];
NSMutableSet *seen = [NSMutableSet set];
for (id obj in originalArray) {
if (![seen containsObject:obj]) {
[unique addObject:obj];
[seen addObject:obj];
}
}
Это все еще кажется немного расточительным; мы все еще генерируем новый массив, когда вопрос прояснил, что исходный массив является изменяемым, поэтому мы должны иметь возможность его дедупликации и сэкономить память. Что-то вроде этого:
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++;
}
}
ОБНОВЛЕНИЕ : Юрий Ниязов указал, что мой последний ответ на самом деле работает в O (N 2 ), потому что, removeObjectAtIndex:вероятно, работает в O (N) времени.
(Он говорит «вероятно», потому что мы не знаем наверняка, как это реализовано; но одна из возможных реализаций состоит в том, что после удаления объекта с индексом X метод затем проходит по каждому элементу от индекса X + 1 до последнего объекта в массиве , перемещая их в предыдущий индекс. Если это так, то это действительно производительность O (N).)
Так что делать? Это зависит от ситуации. Если у вас большой массив и вы ожидаете только небольшое количество дубликатов, то дедупликация на месте будет работать нормально и избавит вас от необходимости создавать дублирующий массив. Если у вас есть массив, в котором вы ожидаете много дубликатов, то, вероятно, лучше всего создать отдельный дедуплицированный массив. Вывод здесь заключается в том, что нотация big-O описывает только характеристики алгоритма, он не будет однозначно сообщать вам, какой вариант лучше всего подходит для любого конкретного обстоятельства.