Objective-Cでのソート方法10選！初心者でもわかる完全ガイド

// NSArrayを使用した基本的なソートのサンプルコード
NSArray *originalArray = @[@5, @3, @8, @1, @4];
NSArray *sortedArray = [originalArray sortedArrayUsingSelector:@selector(compare:)];

// NSSortDescriptorを使用したソートのサンプルコード
NSArray *people = @[@{@"name": @"田中", @"age": @25},
                   @{@"name": @"佐藤", @"age": @30},
                   @{@"name": @"鈴木", @"age": @22}];
NSSortDescriptor *sortDescriptor;
sortDescriptor = [[NSSortDescriptor alloc] initWithKey:@"age"
                                              ascending:YES];
NSArray *sortedPeople = [people sortedArrayUsingDescriptors:@[sortDescriptor]];

NSArray *originalArray = @[@3, @1, @4, @2];
NSArray *sortedArray = [originalArray sortedArrayUsingComparator:^NSComparisonResult(id obj1, id obj2) {
    return [obj1 compare:obj2];
}];

@interface Person : NSObject
@property (nonatomic, strong) NSString *name;
@property (nonatomic, assign) NSInteger age;
@end

Person *person1 = [[Person alloc] init];
person1.name = @"A";
person1.age = 25;

Person *person2 = [[Person alloc] init];
person2.name = @"B";
person2.age = 20;

NSArray *peopleArray = @[person1, person2];
NSSortDescriptor *ageSortDescriptor = [[NSSortDescriptor alloc] initWithKey:@"age" ascending:YES];
NSArray *sortedPeople = [peopleArray sortedArrayUsingDescriptors:@[ageSortDescriptor]];

#import <Foundation/Foundation.h>

int main() {
    @autoreleasepool {
        NSArray *numbers = @[@5, @3, @9, @1, @4];
        dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
        __block NSArray *sortedNumbers;

        dispatch_async(queue, ^{
            sortedNumbers = [numbers sortedArrayUsingComparator:^NSComparisonResult(id obj1, id obj2) {
                NSNumber *num1 = (NSNumber *)obj1;
                NSNumber *num2 = (NSNumber *)obj2;
                return [num1 compare:num2];
            }];
        });

        dispatch_barrier_sync(queue, ^{
            NSLog(@"%@", sortedNumbers);
        });
    }
    return 0;
}

#import <Foundation/Foundation.h>

int main() {
    @autoreleasepool {
        NSArray *numbers = @[@5, @3, @9, @2, @4, @8];
        NSPredicate *evenPredicate = [NSPredicate predicateWithBlock:^BOOL(id evaluatedObject, NSDictionary *bindings) {
            return [evaluatedObject integerValue] % 2 == 0;
        }];
        NSArray *evenNumbers = [numbers filteredArrayUsingPredicate:evenPredicate];
        NSArray *sortedEvenNumbers = [evenNumbers sortedArrayUsingComparator:^NSComparisonResult(id obj1, id obj2) {
            return [obj1 compare:obj2];
        }];

        NSLog(@"%@", sortedEvenNumbers);
    }
    return 0;
}

#import <YourFastLibrary/FastSort.h>

NSMutableArray *array = [NSMutableArray arrayWithObjects:@3, @1, @4, @1, @5, @9, nil];
[array fastSortUsingLibrary];

void binarySort(NSMutableArray *array) {
    NSInteger countZeros = 0;
    for (NSNumber *num in array) {
        if ([num intValue] == 0) {
            countZeros++;
        }
    }

    for (NSInteger i = 0; i < countZeros; i++) {
        array[i] = @0;
    }

    for (NSInteger i = countZeros; i < array.count; i++) {
        array[i] = @1;
    }
}

NSMutableArray *binaryArray = [NSMutableArray arrayWithObjects:@1, @0, @1, @0, @1, nil];
binarySort(binaryArray);

#import <Foundation/Foundation.h>

@interface MergeSort : NSObject
+ (NSArray *)sortArray:(NSArray *)unsortedArray;
@end

@implementation MergeSort
+ (NSArray *)sortArray:(NSArray *)unsortedArray {
    if ([unsortedArray count] < 2)
        return unsortedArray;

    long middle = [unsortedArray count] / 2;
    NSRange leftRange = NSMakeRange(0, middle);
    NSRange rightRange = NSMakeRange(middle, [unsortedArray count] - middle);

    NSArray *leftArray = [MergeSort sortArray:[unsortedArray subarrayWithRange:leftRange]];
    NSArray *rightArray = [MergeSort sortArray:[unsortedArray subarrayWithRange:rightRange]];

    return [MergeSort mergeLeftArray:leftArray rightArray:rightArray];
}

+ (NSArray *)mergeLeftArray:(NSArray *)leftArray rightArray:(NSArray *)rightArray {
    NSMutableArray *result = [NSMutableArray array];
    int leftIndex = 0;
    int rightIndex = 0;

    while (leftIndex < [leftArray count] && rightIndex < [rightArray count]) {
        if ([leftArray[leftIndex] intValue] < [rightArray[rightIndex] intValue]) {
            [result addObject:leftArray[leftIndex++]];
        } else {
            [result addObject:rightArray[rightIndex++]];
        }
    }

    while (leftIndex < [leftArray count]) {
        [result addObject:leftArray[leftIndex++]];
    }

    while (rightIndex < [rightArray count]) {
        [result addObject:rightArray[rightIndex++]];
    }

    return result;
}
@end

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        NSArray *unsortedArray = @[@5, @1, @9, @3, @7, @6, @8, @2, @4, @0];
        NSLog(@"Sorted Array: %@", [MergeSort sortArray:unsortedArray]);
    }
    return 0;
}

#import <Foundation/Foundation.h>

@interface QuickSort : NSObject
+ (NSArray *)sortArray:(NSMutableArray *)unsortedArray;
@end

@implementation QuickSort
+ (NSArray *)sortArray:(NSMutableArray *)unsortedArray {
    if ([unsortedArray count] <= 1)
        return unsortedArray;

    int pivotIndex = [unsortedArray count] / 2;
    NSNumber *pivotValue = unsortedArray[pivotIndex];
    [unsortedArray removeObjectAtIndex:pivotIndex];

    NSMutableArray *lessThanPivot = [NSMutableArray array];
    NSMutableArray *greaterThanPivot = [NSMutableArray array];

    for (NSNumber *num in unsortedArray) {
        if ([num intValue] < [pivotValue intValue]) {
            [lessThanPivot addObject:num];
        } else {
            [greaterThanPivot addObject:num];
        }
    }

    NSMutableArray *sortedArray = [NSMutableArray arrayWithArray:[QuickSort sortArray:lessThanPivot]];
    [sortedArray addObject:pivotValue];
    [sortedArray addObjectsFromArray:[QuickSort sortArray:greaterThanPivot]];

    return sortedArray;
}
@end

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        NSMutableArray *unsortedArray = [NSMutableArray arrayWithObjects:@5, @1, @9, @3, @7, @6, @8, @2, @4, @0, nil];
        NSLog(@"Sorted Array: %@", [QuickSort sortArray:unsortedArray]);
    }
    return 0;
}

#import <UIKit/UIKit.h>

@interface ViewController : UIViewController<UITableViewDelegate, UITableViewDataSource>

@property (strong, nonatomic) NSArray *sortedData;
@property (weak, nonatomic) IBOutlet UITableView *tableView;

@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];

    // データの準備
    NSArray *data = @[@"apple", @"orange", @"banana", @"grape"];
    self.sortedData = [data sortedArrayUsingSelector:@selector(compare:)];

    // TableViewの設定
    self.tableView.delegate = self;
    self.tableView.dataSource = self;
}

// TableViewのセルの数を指定
- (NSInteger)tableView:(UITableView *)tableView numberOfRowsInSection:(NSInteger)section {
    return [self.sortedData count];
}

// 各セルの内容を設定
- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath {
    UITableViewCell *cell = [tableView dequeueReusableCellWithIdentifier:@"cell" forIndexPath:indexPath];
    cell.textLabel.text = self.sortedData[indexPath.row];
    return cell;
}

@end

#import <Foundation/Foundation.h>

@interface SearchHelper : NSObject

+ (NSInteger)binarySearchFor:(NSArray *)array value:(NSString *)value;

@end

@implementation SearchHelper

+ (NSInteger)binarySearchFor:(NSArray *)array value:(NSString *)value {
    NSInteger low = 0;
    NSInteger high = [array count] - 1;

    while (low <= high) {
        NSInteger mid = (low + high) / 2;
        NSString *midValue = array[mid];

        NSComparisonResult result = [value compare:midValue];

        if (result == NSOrderedSame) {
            return mid;
        } else if (result == NSOrderedAscending) {
            high = mid - 1;
        } else {
            low = mid + 1;
        }
    }
    return NSNotFound;
}

@end

NSArray *array = /* ... */;
@synchronized(array) {
    // ソート処理
    NSArray *sortedArray = [array sortedArrayUsingSelector:@selector(compare:)];
}

NSArray *stringsArray = @[@"apple", @"banana", @"cherry", @"date"];
NSArray *sortedArray = [stringsArray sortedArrayUsingComparator:^NSComparisonResult(NSString *str1, NSString *str2) {
    if (str1.length < str2.length) {
        return NSOrderedAscending;
    } else if (str1.length > str2.length) {
        return NSOrderedDescending;
    } else {
        return NSOrderedSame;
    }
}];

NSArray *originalSortedArray = @[@1, @3, @5, @7, @9];
NSArray *newDataArray = @[@2, @4, @6];
NSArray *combinedArray = [originalSortedArray arrayByAddingObjectsFromArray:newDataArray];
NSArray *fullySortedArray = [combinedArray sortedArrayUsingSelector:@selector(compare:)];

NSArray *dataArray = @[@1, @5, @2, @8, @3, @7];
NSPredicate *filter = [NSPredicate predicateWithFormat:@"SELF < 5"];
NSArray *filteredArray = [dataArray filteredArrayUsingPredicate:filter];
NSArray *sortedFilteredArray = [filteredArray sortedArrayUsingSelector:@selector(compare:)];