হ্যাঁ, এনএসএসেট ব্যবহার করা একটি বোধগম্য পদ্ধতি।
জিম পালসের উত্তরে যুক্ত করতে, অর্ডার বজায় রেখে ডুপ্লিকেটগুলি সরিয়ে ফেলার বিকল্প বিকল্প এখানে রয়েছে:
// Initialise a new, empty mutable array
NSMutableArray *unique = [NSMutableArray array];
for (id obj in originalArray) {
if (![unique containsObject:obj]) {
[unique addObject:obj];
}
}
এটি মূলত জিমের মতোই একই পদ্ধতির তবে অনুলিপি আইটেমগুলিকে আসল থেকে নকল মুছে ফেলার পরিবর্তে একটি তাজা পরিবর্তনযোগ্য অ্যারে অনুলিপি করে। প্রচুর নকল (পুরো অ্যারের একটি অনুলিপি তৈরি করার প্রয়োজন নেই) সহ বৃহত অ্যারের ক্ষেত্রে এটি সামান্য আরও মেমরির দক্ষ করে তোলে এবং আমার মতে এটি আরও কিছুটা পাঠযোগ্য read
মনে রাখবেন যে উভয় ক্ষেত্রেই, কোনও আইটেম ইতিমধ্যে লক্ষ্য অ্যারেতে অন্তর্ভুক্ত রয়েছে কিনা তা পরীক্ষা করে নেওয়া ( containsObject:আমার উদাহরণে বা indexOfObject:inRange:জিমের ব্যবহার করে) বড় অ্যারেগুলিতে ভাল স্কেল করে না। এই চেকগুলি ও (এন) সময়ে চালিত হয়, এর অর্থ আপনি যদি মূল অ্যারের আকার দ্বিগুণ করেন তবে প্রতিটি চেক চালাতে দ্বিগুণ সময় নিতে হবে। যেহেতু আপনি অ্যারেতে প্রতিটি বস্তুর জন্য চেক করছেন, তাই আপনি আরও বেশি ব্যয়বহুল চেকগুলি আরও চালাবেন। সামগ্রিক অ্যালগরিদম (আমার এবং জিম উভয়ই) ও (এন 2 ) সময়ে চলে যা মূল অ্যারে বাড়ার সাথে সাথে ব্যয়বহুল হয়ে ওঠে।
ও (এন) এর সময় নেওয়ার জন্য আপনি NSMutableSetইতিমধ্যে নতুন অ্যারেতে যুক্ত হওয়া আইটেমগুলির একটি রেকর্ড সংরক্ষণ করতে একটি ব্যবহার করতে পারেন , যেহেতু এনএসএসেট লকআপগুলি ও (এন) এর পরিবর্তে ও (1) হয়। অন্য কথায়, কোনও উপাদান এনএসএসেটের সদস্য কিনা তা যাচাই করতে সেটে কতগুলি উপাদান রয়েছে তা নির্বিশেষে একই সময় নেয়।
এই পদ্ধতির সাহায্যে কোডটি দেখতে এরকম কিছু দেখতে পাবে:
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 থেকে অ্যারের শেষ অবজেক্টে প্রতিটি উপাদানকে লুপ করে তোলে) , তাদের পূর্বের সূচকে সরানো।
তো এখন কি করা? এটা পরিস্থিতির উপর নির্ভর করে। যদি আপনি একটি বড় অ্যারে পেয়ে থাকেন এবং আপনি কেবলমাত্র কয়েকটি সংখ্যক নকলের প্রত্যাশা করছেন তবে স্থানের ডি-সদৃশটি ঠিক কাজ করবে এবং আপনাকে একটি সদৃশ অ্যারে তৈরির সংরক্ষণ করবে। যদি আপনি এমন একটি অ্যারে পেয়ে থাকেন যেখানে আপনি প্রচুর নকলের প্রত্যাশা করছেন তবে আলাদা, ডি-ডুপড অ্যারে তৈরি করা সম্ভবত সেরা পন্থা। এখানে সরানোর বিষয়টি হ'ল বিগ-ও স্বরলিপিটি কেবল একটি অ্যালগরিদমের বৈশিষ্ট্য বর্ণনা করে, এটি আপনাকে নির্দিষ্ট করে বলতে পারে না যে কোনও প্রদত্ত পরিস্থিতিতে সবচেয়ে ভাল।