Ya, menggunakan NSSet adalah pendekatan yang masuk akal.
Untuk menambah jawaban Jim Puls, berikut adalah pendekatan alternatif untuk menghapus duplikat sambil mempertahankan pesanan:
// Initialise a new, empty mutable array
NSMutableArray *unique = [NSMutableArray array];
for (id obj in originalArray) {
if (![unique containsObject:obj]) {
[unique addObject:obj];
}
}
Ini pada dasarnya pendekatan yang sama dengan Jim tetapi menyalin item unik ke array yang bisa berubah baru daripada menghapus duplikat dari aslinya. Ini membuatnya sedikit lebih efisien dalam hal array besar dengan banyak duplikat (tidak perlu membuat salinan seluruh array), dan menurut saya sedikit lebih mudah dibaca.
Perhatikan bahwa dalam kedua kasus, memeriksa untuk melihat apakah item sudah termasuk dalam array target (menggunakan containsObject:dalam contoh saya, atau indexOfObject:inRange:dalam Jim) tidak skala dengan baik untuk array besar. Pemeriksaan tersebut berjalan dalam waktu O (N), yang berarti bahwa jika Anda menggandakan ukuran array asli maka setiap pemeriksaan akan memakan waktu dua kali lebih lama untuk dijalankan. Karena Anda melakukan pemeriksaan untuk setiap objek dalam array, Anda juga akan menjalankan lebih banyak dari pemeriksaan yang lebih mahal itu. Algoritma keseluruhan (baik milik saya maupun Jim) berjalan dalam waktu O (N 2 ), yang menjadi cepat mahal seiring dengan tumbuhnya array asli.
Untuk menurunkannya ke waktu O (N), Anda bisa menggunakan a NSMutableSetuntuk menyimpan catatan item yang sudah ditambahkan ke array baru, karena pencarian NSSet adalah O (1) daripada O (N). Dengan kata lain, memeriksa untuk melihat apakah suatu elemen adalah anggota NSSet membutuhkan waktu yang sama terlepas dari berapa banyak elemen dalam set.
Kode yang menggunakan pendekatan ini akan terlihat seperti ini:
NSMutableArray *unique = [NSMutableArray array];
NSMutableSet *seen = [NSMutableSet set];
for (id obj in originalArray) {
if (![seen containsObject:obj]) {
[unique addObject:obj];
[seen addObject:obj];
}
}
Ini tampaknya masih sedikit boros; kami masih membuat array baru ketika pertanyaan menjelaskan bahwa array asli bisa berubah, jadi kita harus dapat menghapusnya di tempat dan menghemat memori. Sesuatu seperti ini:
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 menunjukkan bahwa jawaban terakhir saya benar-benar berjalan di O (N 2 ) karena removeObjectAtIndex:mungkin berjalan dalam waktu O (N).
(Dia mengatakan "mungkin" karena kita tidak tahu pasti bagaimana itu diterapkan; tetapi satu kemungkinan implementasi adalah bahwa setelah menghapus objek pada indeks X metode kemudian loop melalui setiap elemen dari indeks X + 1 ke objek terakhir dalam array , memindahkan mereka ke indeks sebelumnya. Jika itu masalahnya maka itu memang kinerja O (N).)
Jadi, apa yang harus dilakukan? Itu tergantung situasi. Jika Anda memiliki array besar dan Anda hanya mengharapkan sejumlah kecil duplikat maka de-duplikasi di tempat akan bekerja dengan baik dan menghemat Anda harus membangun array duplikat. Jika Anda memiliki array di mana Anda mengharapkan banyak duplikat kemudian membangun array terpisah, de-duped mungkin merupakan pendekatan terbaik. Yang dibawa pulang di sini adalah bahwa notasi-O besar hanya menggambarkan karakteristik suatu algoritma, itu tidak akan memberi tahu Anda secara definitif mana yang terbaik untuk keadaan apa pun.