दो एनएसएआरएआरई को एक तरफ

Question

क्रमबद्ध करना मेरे पास कई सरणी हैं जिन्हें एक तरफ क्रमबद्ध करने की आवश्यकता है।

उदाहरण के लिए, पहले सरणी में नाम हैं: @[@"Joe", @"Anna", @"Michael", @"Kim"], और और अन्य सरणी में पते हैं: @[@"Hollywood bld", @"Some street 3", @"That other street", @"country road"], जहां सरणी इंडेक्स एक साथ जाते हैं। "जो" "हॉलीवुड बीएलडी" में रहता है और इसी तरह।

मैं नाम सरणी को क्रमबद्ध रूप से क्रमबद्ध करना चाहता हूं, और फिर पता सरणी को साथ क्रमबद्ध करना है ताकि वे अभी भी "हॉलीवुड बीएलडी" के साथ "जो" के समान इंडेक्स के साथ मिल जाए। मुझे पता है कि

NSSortDescriptor *sort=[NSSortDescriptor sortDescriptorWithKey:@"name" ascending:NO]; 
[myArray sortUsingDescriptors:[NSArray arrayWithObject:sort]]; 

के साथ एक सरणी वर्णमाला सॉर्ट लेकिन वहाँ होने का कोई आसान तरीका दूसरी सरणी उचित आदेश का प्रयोग कर रहा है के लिए?

Answer 1

1. क्रमपरिवर्तन सरणी, शुरू करने के लिए p[i]=i
2. क्रमबद्ध क्रमचय समूह बनाएं पहली सरणी
3. की name कुंजी के अनुसार पुनः आदेश देने के दोनों सरणियों क्रमचय का प्रयोग करें

उदाहरण: मान लें कि पहला सरणी {"quick", "brown", "fox"} है। क्रमपरिवर्तन {0, 1, 2} के रूप में शुरू होता है, और इस प्रकार के बाद {1, 2, 0} बन जाता है। अब आप क्रमपरिवर्तन सरणी के माध्यम से जा सकते हैं, और आवश्यकतानुसार मूल सरणी और दूसरी सरणी को फिर से ऑर्डर कर सकते हैं।

NSArray *first = [NSArray arrayWithObjects: @"quick", @"brown", @"fox", @"jumps", nil]; 
NSArray *second = [NSArray arrayWithObjects: @"jack", @"loves", @"my", @"sphinx", nil]; 
NSMutableArray *p = [NSMutableArray arrayWithCapacity:first.count]; 
for (NSUInteger i = 0 ; i != first.count ; i++) { 
    [p addObject:[NSNumber numberWithInteger:i]]; 
} 
[p sortWithOptions:0 usingComparator:^NSComparisonResult(id obj1, id obj2) { 
    // Modify this to use [first objectAtIndex:[obj1 intValue]].name property 
    NSString *lhs = [first objectAtIndex:[obj1 intValue]]; 
    // Same goes for the next line: use the name 
    NSString *rhs = [first objectAtIndex:[obj2 intValue]]; 
    return [lhs compare:rhs]; 
}]; 
NSMutableArray *sortedFirst = [NSMutableArray arrayWithCapacity:first.count]; 
NSMutableArray *sortedSecond = [NSMutableArray arrayWithCapacity:first.count]; 
[p enumerateObjectsUsingBlock:^(id obj, NSUInteger idx, BOOL *stop) { 
    NSUInteger pos = [obj intValue]; 
    [sortedFirst addObject:[first objectAtIndex:pos]]; 
    [sortedSecond addObject:[second objectAtIndex:pos]]; 
}]; 
NSLog(@"%@", sortedFirst); 
NSLog(@"%@", sortedSecond); 

Answer 2

आप शायद पहले और प्रकार के बाद वस्तुओं की अनुक्रमणिका का ट्रैक रखने कर ऐसा कर सकता है, लेकिन हो सकता है यह आसान एक वस्तु जो हैस इन गुणों के सभी

Person : NSObject 

@property (nonatomic, copy) NSString *name; 
@property (nonatomic, copy) NSString *addresss; 

तो फिर तुम में इन वस्तुओं की दुकान होने होगा एक एकल सरणी जिसे आप name, या address कुंजी पथ

Answer 3

सबसे अच्छा तरीका अपने डेटा को पुन: स्थापित करना है ताकि आपके पास केवल एक सरणी हो। आपके उदाहरण में, यह नाम और पता दोनों के साथ एक नई कक्षा बनाने के लिए सबसे अधिक समझदारी होगी, उन्हें एक सरणी में रखें और इसे नाम से सॉर्ट करें।

Answer 4

सबसे पहले, आप एक वास्तुकला है कि आप इस तरह एक समानांतर फैशन में दो सरणियों सॉर्ट करने के लिए की आवश्यकता है फिर से विचार करना चाह सकते। लेकिन ऐसा कहा जाता है कि, आप शब्दकोशों की एक अस्थायी सरणी बनाकर ऐसा कर सकते हैं जो दो सरणी के तत्वों को जोड़ता है।

तो फिर तुम संयुक्त सरणी सॉर्ट, और दो सरणियों फिर से, के रूप में अनुरोध किया अनुसार क्रमबद्ध निकालें:

मूल डेटा:

NSArray *names  = @[@"Joe", @"Anna", @"Michael"]; 
NSArray *addresses = @[@"Hollywood bld", @"Some street 3", @"That other street"]; 

वास्तविक छंटाई कोड:

NSMutableArray *combined = [NSMutableArray array]; 

for (NSUInteger i = 0; i < names.count; i++) { 
    [combined addObject: @{@"name" : names[i], @"address": addresses[i]}]; 
} 

[combined sortUsingDescriptors:@[[NSSortDescriptor sortDescriptorWithKey:@"name" ascending:YES]]]; 

names  = [combined valueForKey:@"name"]; 
addresses = [combined valueForKey:@"address"]; 

सूचना है कि valueForKey: सरणी पर प्रयुक्त एक ही आकार के साथ एक नई सरणी निकालता है, जो मूल सरणी में ऑब्जेक्ट्स के गुणों के साथ पॉप्युलेट होता है। इस मामले में, यह वांछित के रूप में क्रमबद्ध, मूल से नए सरणी बनाते हैं।

इस दृष्टिकोण को केवल कोड की कुछ पंक्तियों की आवश्यकता है और यदि आवश्यक हो, तो इसका पालन करना और डीबग करना आसान है।