Sorting a array of int with Objective-C - Optimizing

Question

This morning, I stumbled on this thread Why is it faster to process a sorted array than an unsorted array? and found it really interesting !

I wanted to give it a try in Objective-C and while implementing it, I faced the problem of sorting an array of integers. Hence the following question.

Let's consider an array of arraySize integers, initialized with random values between 0 and 256:

int data[arraySize];
for (int c = 0; c < arraySize; ++c)
{
    data[c] = arc4random() % 256;
}

I would like to sort this array and store the result in another array of integers. In C++ we could do something like :

std::sort(data, ...);

In Java, we would use :

Arrays.sort(data);

In Objective-C, I've done it like that :

int sortedData[arraySize];
NSArray* sortedArray = [NSArray array];
// Initialize the array to sort.
for ( int i = 0 ; i < arraySize ; ++i )
{
    sortedArray = [sortedArray arrayByAddingObject:[NSNumber numberWithInt:data[i]]];
}
// Sort the array.
sortedArray = [sortedArray sortedArrayUsingSelector:@selector(compare:)];
// Copy the array back into a int[] array.
for (int c = 0; c < arraySize; ++c)
{
    sortedData[c] = [sortedArray[c] intValue];
}

It works, but it seems to me it's a real pain and it's not optimized at all ! How could I improve this ?

Answer 1

The "non-optimized" statement is true only for the code you have. Apple's frameworks are highly optimized and you're not supposed to second guess Apple, they've already second guessed you.

First, use methods for the purpose they have been created for. The way you're creating the unsorted array just wastes memory. In every single step of the loop, you're creating a new instance of the array, in the end, you'll end up with 256 (or whatever the count of the original integer array is) arrays, that's just superfluous.

So, if you really, badly want to use Objective-C for solving this problem, you can use a mutable array and you will only need one NSMutableArray:

int array[256];
// populate the C array here

NSMutableArray *objcArray = [NSMutableArray array];
for (int i = 0; i < sizeof(array) / sizeof(*array); i++) {
    [objcArray addObject:[NSNumber numberWithInt:array[i]];
}

[objcArray sortUsingSelector:@selector(compare:)];

By the way, even the two loops (one for populating the C array and one for transforming it into an NSMutableArray) are unnecessary here. You could just write

const size_t size = 256;
NSMutableArray *objcArray = [NSMutableArray array];
for (int i = 0; i < size; i++) {
    [objcArray addObject:[NSNumber numberWithInt:arc4random_uniform(256)];
}

[objcArray sortUsingSelector:@selector(compare:)];

However, you don't really need Objective-C for sorting an integer array. You can simply write a C function (or if you want, an Objective-C method) for sorting the integer array in-place, and that can be somewhat more efficient or faster:

#include <math.h>
#include <stdlib.h>
#include <unistd.h>

int compare(const void *first, const void *second)
{
    return *(const int *)first - *(const int *)second;
}

- (void)sortArray:(int *)array ofSize:(size_t)sz
{
    qsort(array, sz, sizeof(*array), compare);
}

Then use it like this:

int array[256];
for (int i = 0; i < sizeof(array) / sizeof(*array); i++) {
    array[i] = arc4random_uniform(256);
}

[self sortArray:array ofSize:sizeof(array) / sizeof(*array)];

Also, read this about arrays. Really good article.

Answer 2

What about using NSSortDescriptor?

NSSortDescriptor *descriptor = [[NSSortDescriptor alloc] initWithKey:@"propertieToSort" ascending:NO];
NSArray *descArray = [NSArray arrayWithObject:dateDescriptor];
representedItems = [unsortedItems sortedArrayUsingDescriptors:descArray];

I'm not 100% sure this will work with non NSObjects but I swear I used it sometime.

Answer 3

You can use c++ in your obj-c project, just rename your file into .mm and add #include < algorithm > for using std.sort. I think, it will be faster that using NSNumber for int data