हां, 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:जिम में) बड़े सरणियों के लिए अच्छी तरह से स्केल नहीं करता है। वे चेक ओ (एन) समय में चलते हैं, जिसका अर्थ है कि यदि आप मूल सरणी के आकार को दोगुना करते हैं तो प्रत्येक चेक को चलने में दोगुना समय लगेगा। जब से आप सरणी में प्रत्येक ऑब्जेक्ट के लिए चेक कर रहे हैं, तो आप उन अधिक महंगी चेक को भी चला रहे होंगे। समग्र एल्गोरिथ्म (मेरा और जिम दोनों) ओ (एन 2 ) समय में चलता है , जो मूल सरणी बढ़ने के साथ जल्दी महंगा हो जाता है।
उस डाउन टू ओ (एन) समय को प्राप्त करने के लिए आप NSMutableSetनए एरे में पहले से जोड़े गए आइटमों के रिकॉर्ड को स्टोर करने के लिए उपयोग कर सकते हैं , क्योंकि एनएसएसईटी लुकअप ओ (एन) के बजाय ओ (1) हैं। दूसरे शब्दों में, यह देखने के लिए कि क्या कोई तत्व 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++;
}
}
अद्यतन : यूरी नियाज़ोव ने बताया कि मेरा अंतिम उत्तर वास्तव में ओ (एन 2 ) removeObjectAtIndex:में चलता है क्योंकि शायद ओ (एन) समय में चलता है।
(वे कहते हैं "शायद" क्योंकि हम यह सुनिश्चित करने के लिए नहीं जानते हैं कि यह कैसे लागू किया जाता है, लेकिन एक संभव कार्यान्वयन यह है कि ऑब्जेक्ट को इंडेक्स एक्स पर हटाने के बाद विधि फिर एरे में एक्स + 1 से आखिरी ऑब्जेक्ट तक हर तत्व से गुजरती है। , उन्हें पिछले सूचकांक में ले जाना। यदि ऐसा है तो वास्तव में O (N) प्रदर्शन है।)
इसलिए क्या करना है? यह स्थिति पर निर्भर करता है। यदि आपको एक बड़ा सरणी मिला है और आप केवल बहुत सारे डुप्लिकेट की उम्मीद कर रहे हैं तो इन-प्लेस डे-डुप्लीकेशन ठीक काम करेगा और आपको डुप्लिकेट सरणी बनाने के लिए बचाएगा। यदि आपको एक ऐसा सरणी मिला है जहाँ आप बहुत सारे डुप्लिकेट की उम्मीद कर रहे हैं तो एक अलग, डी-डुप्ड सरणी का निर्माण करना संभवतः सबसे अच्छा तरीका है। यहाँ ले दूर यह है कि बड़ा- O अंकन केवल एक एल्गोरिथ्म की विशेषताओं का वर्णन करता है, यह आपको निश्चित रूप से नहीं बताएगा जो किसी भी परिस्थिति के लिए सबसे अच्छा है।