Ja, die Verwendung von NSSet ist ein sinnvoller Ansatz.
Um die Antwort von Jim Puls zu ergänzen, gibt es hier einen alternativen Ansatz zum Entfernen von Duplikaten unter Beibehaltung der Reihenfolge:
// Initialise a new, empty mutable array
NSMutableArray *unique = [NSMutableArray array];
for (id obj in originalArray) {
if (![unique containsObject:obj]) {
[unique addObject:obj];
}
}
Es ist im Wesentlichen der gleiche Ansatz wie bei Jim, kopiert jedoch eindeutige Elemente in ein neues veränderbares Array, anstatt Duplikate aus dem Original zu löschen. Dies macht es etwas speichereffizienter bei einem großen Array mit vielen Duplikaten (es ist nicht erforderlich, eine Kopie des gesamten Arrays zu erstellen) und ist meiner Meinung nach etwas lesbarer.
Beachten Sie, dass in beiden Fällen die Überprüfung, ob ein Element bereits im Zielarray enthalten ist ( containsObject:in meinem Beispiel oder indexOfObject:inRange:in Jims), für große Arrays nicht gut skalierbar ist. Diese Überprüfungen werden in O (N) -Zeit ausgeführt. Wenn Sie also die Größe des ursprünglichen Arrays verdoppeln, dauert die Ausführung jeder Überprüfung doppelt so lange. Da Sie die Prüfung für jedes Objekt im Array durchführen, führen Sie auch mehr dieser teureren Prüfungen durch. Der Gesamtalgorithmus (sowohl meiner als auch Jims) läuft in O (N 2 ) -Zeit, was schnell teuer wird, wenn das ursprüngliche Array wächst.
Um dies auf O (N) Zeit zu NSMutableSetreduzieren, können Sie mit a einen Datensatz von Elementen speichern, die bereits zum neuen Array hinzugefügt wurden, da NSSet-Lookups O (1) und nicht O (N) sind. Mit anderen Worten, die Überprüfung, ob ein Element Mitglied eines NSSet ist, dauert unabhängig von der Anzahl der Elemente in der Gruppe dieselbe Zeit.
Code, der diesen Ansatz verwendet, würde ungefähr so aussehen:
NSMutableArray *unique = [NSMutableArray array];
NSMutableSet *seen = [NSMutableSet set];
for (id obj in originalArray) {
if (![seen containsObject:obj]) {
[unique addObject:obj];
[seen addObject:obj];
}
}
Dies scheint jedoch immer noch ein wenig verschwenderisch; Wir generieren immer noch ein neues Array, wenn die Frage klarstellt, dass das ursprüngliche Array veränderbar ist. Daher sollten wir in der Lage sein, es zu entfernen und Speicherplatz zu sparen. Etwas wie das:
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++;
}
}
UPDATE : Yuri Niyazov wies darauf hin, dass meine letzte Antwort tatsächlich in O (N 2 ) removeObjectAtIndex:läuft, weil sie wahrscheinlich in O (N) läuft.
(Er sagt "wahrscheinlich", weil wir nicht genau wissen, wie es implementiert ist. Eine mögliche Implementierung ist jedoch, dass die Methode nach dem Löschen des Objekts am Index X jedes Element vom Index X + 1 bis zum letzten Objekt im Array durchläuft Wenn dies der Fall ist, ist dies tatsächlich die O (N) -Leistung.)
Also, was tun? Es hängt von der Situation ab. Wenn Sie ein großes Array haben und nur eine kleine Anzahl von Duplikaten erwarten, funktioniert die direkte Deduplizierung einwandfrei und Sie müssen kein doppeltes Array erstellen. Wenn Sie ein Array haben, in dem Sie viele Duplikate erwarten, ist der Aufbau eines separaten, nicht duplizierten Arrays wahrscheinlich der beste Ansatz. Das Mitnehmen hier ist, dass die Big-O-Notation nur die Eigenschaften eines Algorithmus beschreibt und Ihnen nicht definitiv sagt, welche für einen bestimmten Umstand am besten ist.