ใช่การใช้ NSSet เป็นแนวทางที่สมเหตุสมผล
หากต้องการเพิ่มคำตอบของ Jim Puls ต่อไปนี้เป็นวิธีการอื่นในการลอกรายการที่ซ้ำกันในขณะที่รักษาลำดับ:
// Initialise a new, empty mutable array
NSMutableArray *unique = [NSMutableArray array];
for (id obj in originalArray) {
if (![unique containsObject:obj]) {
[unique addObject:obj];
}
}
โดยพื้นฐานแล้วมันเป็นวิธีการเดียวกับของ Jim แต่คัดลอกรายการที่ไม่ซ้ำกันไปยังอาร์เรย์ที่ไม่แน่นอนซึ่งสดใหม่แทนที่จะลบรายการที่ซ้ำจากต้นฉบับ ทำให้หน่วยความจำมีประสิทธิภาพมากขึ้นเล็กน้อยในกรณีของอาเรย์ขนาดใหญ่ที่มีการซ้ำซ้อนจำนวนมาก (ไม่จำเป็นต้องทำสำเนาของทั้งอาเรย์) และฉันคิดว่าสามารถอ่านได้อีกเล็กน้อย
โปรดทราบว่าในกรณีใดกรณีหนึ่งการตรวจสอบเพื่อดูว่ามีรายการรวมอยู่ในอาร์เรย์เป้าหมาย (ใช้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++;
}
}
UPDATE : Yuri Niyazov ชี้ให้เห็นว่าคำตอบสุดท้ายของฉันทำงานจริงใน O (N 2 ) เพราะremoveObjectAtIndex:อาจทำงานในเวลา O (N)
(เขาบอกว่า "อาจจะ" เพราะเราไม่รู้ว่ามันถูกนำไปใช้อย่างไร แต่สิ่งหนึ่งที่เป็นไปได้คือการนำไปใช้หลังจากการลบวัตถุที่ index X วิธีนั้นจะวนซ้ำทุกองค์ประกอบจากดัชนี X + 1 ไปยังวัตถุสุดท้ายในอาร์เรย์ ให้ย้ายพวกมันไปยังดัชนีก่อนหน้าถ้าเป็นเช่นนั้นประสิทธิภาพ O (N) จะเป็นจริง)
แล้วจะทำอย่างไรดี? มันขึ้นอยู่กับสถานการณ์ หากคุณมีอาร์เรย์จำนวนมากและคุณคาดหวังว่าจะมีจำนวนรายการที่ซ้ำกันเพียงเล็กน้อยการยกเลิกการทำซ้ำแบบแทนที่จะทำงานได้ดีและช่วยให้คุณไม่ต้องสร้างอาร์เรย์ที่ซ้ำกัน หากคุณมีอาเรย์ที่คุณคาดหวังว่าจะมีการซ้ำซ้อนจำนวนมากจากนั้นสร้างอาเรย์แยกต่างหากอาเรย์ที่ซ้ำกันอาจเป็นวิธีที่ดีที่สุด สิ่งที่ต้องทำในที่นี้คือสัญกรณ์ใหญ่ ๆ O อธิบายเฉพาะคุณลักษณะของอัลกอริธึมเท่านั้นมันจะไม่บอกคุณอย่างแน่นอนว่าดีที่สุดสำหรับสถานการณ์ใดก็ตาม