Evet, NSSet kullanmak mantıklı bir yaklaşımdır.
Jim Puls'un cevabına eklemek için, sırayı korurken kopyaları çıkarmaya alternatif bir yaklaşım var:
// Initialise a new, empty mutable array
NSMutableArray *unique = [NSMutableArray array];
for (id obj in originalArray) {
if (![unique containsObject:obj]) {
[unique addObject:obj];
}
}
Aslında Jim'inkiyle aynı yaklaşımdır, ancak orijinali kopyaları silmek yerine benzersiz öğeleri yeni bir değişken diziye kopyalar. Bu, çoğaltılmış çok sayıda (tüm dizinin bir kopyasını oluşturmaya gerek yok) büyük bir dizi durumunda biraz daha bellek verimli hale getirir ve bence biraz daha okunabilir.
Her iki durumda da, bir öğenin hedef diziye zaten dahil edilip edilmediğini kontrol etmenin ( örneğimde containsObject:veya indexOfObject:inRange:Jim'inde) büyük diziler için iyi ölçeklenmediğini unutmayın. Bu kontroller O (N) zamanında çalışır, yani orijinal dizinin boyutunu iki katına çıkarırsanız, her kontrolün çalışması iki kat daha uzun sürer. Dizideki her bir nesne için denetim yaptığınızdan, bu daha pahalı denetimlerin çoğunu da çalıştırırsınız. Genel algoritma (hem benim hem de Jim'in) O (N 2 ) zamanında çalışır ve orijinal dizi büyüdükçe hızlı bir şekilde pahalı olur.
Bunu O (N) zamanına düşürmek için NSMutableSet, yeni diziye zaten eklenmiş olan öğelerin kaydını saklamak için a kullanabilirsiniz , çünkü NSSet aramaları O (N) yerine O (1) şeklindedir. Başka bir deyişle, bir öğenin bir NSSet'in üyesi olup olmadığını kontrol etmek, kümede kaç öğe bulunduğundan bağımsız olarak aynı zamanı alır.
Bu yaklaşımı kullanan kod şöyle görünecektir:
NSMutableArray *unique = [NSMutableArray array];
NSMutableSet *seen = [NSMutableSet set];
for (id obj in originalArray) {
if (![seen containsObject:obj]) {
[unique addObject:obj];
[seen addObject:obj];
}
}
Bu yine de biraz savurgan görünüyor; orijinal dizinin değiştirilebilir olduğunu açıkça belirttikten sonra hala yeni bir dizi oluşturuyoruz, bu yüzden yerinde de-dupe ve biraz bellek tasarrufu yapabilmeliyiz. Bunun gibi bir şey:
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++;
}
}
GÜNCELLEME : Yuri Niyazov , son cevabımın aslında O (N 2 ) 'de, çünkü muhtemelen O (N) zamanda çalıştığına dikkat çekti .removeObjectAtIndex:
("Muhtemelen" diyor çünkü nasıl uygulandığından emin değiliz; ancak olası bir uygulama, X dizinindeki nesneyi sildikten sonra yöntemin X + 1 dizininden dizideki son nesneye kadar her öğeye geçiş yapmasıdır. bunları bir önceki dizine taşıyın. Durum buysa, aslında O (N) performansıdır.)
Peki ne yapmalı? Bu duruma bağlıdır. Büyük bir diziniz varsa ve yalnızca az sayıda kopya bekliyorsanız, yerinde çoğaltma işlemi iyi çalışır ve yinelenen bir dizi oluşturmak zorunda kalmanızı sağlar. Eğer çok sayıda kopya beklediğiniz bir dizi varsa, o zaman ayrı, de-duped dizi oluşturmak muhtemelen en iyi yaklaşımdır. Buradaki devralma, big-O gösteriminin sadece bir algoritmanın özelliklerini tanımlamasıdır, size herhangi bir koşul için en iyisi olduğunu kesin olarak söylemez.