Bubble Sort in Objective-C Following is Objective-C method implementation I did for one of the most simplest sorting algorithms, Bubble Sort to sort an array of integers.

Note:- I have defined it as a static method in the SimpleAlgorithms class.

/**
 * When given jumbled or discending ordered array of integers, following bubble sort method will give you 
 * an array ordered in ascending order.
 */
+ (NSArray *) bubbleSort:(NSArray *) arrayToBeSorted {
    // As we can't swap integers in a static array, make a mutable array out of the given static array.
    NSMutableArray *muArrRaw = [[NSMutableArray alloc] initWithArray:arrayToBeSorted];

    // iterate through the array as rounds
    for (int i = 0; i &lt; [muArrRaw count]; i++) {
        // iterate through each element of the array with the given range
        for (int j = 0; j &lt; [muArrRaw count] - i; j++) {
            // comparison
            if (j &lt; ([muArrRaw count] - 1) &amp;&amp; [[muArrRaw objectAtIndex:j] intValue] &gt; [[muArrRaw objectAtIndex:(j + 1)] intValue]) {
                int temp = [[muArrRaw objectAtIndex:j] intValue];   // taken the value to be swapped first

                // then do the swapping
                [muArrRaw replaceObjectAtIndex:j withObject:[muArrRaw objectAtIndex:(j + 1)]];
                [muArrRaw replaceObjectAtIndex:(j + 1) withObject:[NSNumber numberWithInt:temp]];
            }
        }
    }

    // return the sorted array
    return [muArrRaw mutableCopy];
}


I call this method as follows:

NSArray *array = [[NSArray alloc] initWithObjects:[NSNumber numberWithInt:5], [NSNumber numberWithInt:3], [NSNumber numberWithInt:4], [NSNumber numberWithInt:1], [NSNumber numberWithInt:2], nil];
NSArray *sortedArray = [SimpleAlgorithms bubbleSort:array];


I know this seems to be silly for asking for improvements for something like this. But I like to find out even smallest improvements that we can made to this kind of things also because sometimes I might have done something stupid in the above implementation also. That's where we can embed power and value to the implementation.

So please give your suggestions and improvements to this Algorithm implementation.

I would be grateful if you can point out the improvements in the following areas:


Objective-C Language oriented improvements, reasoning and suggestions
Algorithm implementation techniques, simplifiable code lines.
Returning a mutable copy of the temporary array makes no sense to me,
perhaps you meant

return [muArrRaw copy];


to return an immutable array (as the return type of the method indicates).



The "proper" data type for array indices is NSUInteger, not int.



In

if (j &lt; ([muArrRaw count] - 1) &amp;&amp; [[muArrRaw objectAtIndex:j] intValue] &gt; [[muArrRaw objectAtIndex:(j + 1)] intValue]) {


you can get rid of the extra check j &lt; ([muArrRaw count] - 1) if the
outer loop starts with i = 1.

Also [muArrRaw objectAtIndex:j] can be shortened to muArrRaw[i], 

for (NSUInteger i = 1; i &lt; [muArrRaw count]; i++) {
    for (NSUInteger j = 0; j &lt; [muArrRaw count] - i; j++) {
        if ([muArrRaw[j] intValue] &gt; [muArrRaw[j + 1] intValue]) {
            // ...
        }
    }
}




Swapping two elements in the array can be simplified by using
the existing method:

[muArrRaw exchangeObjectAtIndex:j withObjectAtIndex:j+1];




If no elements were swapped at all in some pass then the array is
already sorted and there is no need to continue: 

BOOL swapped;
NSUInteger n = [muArrRaw count];
do {
    swapped = NO;
    for (NSUInteger j = 0; j + 1 &lt; n; j++) {
        if ([muArrRaw[j] intValue] &gt; [muArrRaw[j + 1] intValue]) {
            [muArrRaw exchangeObjectAtIndex:j withObjectAtIndex:j+1];
            swapped = YES;
        }
    }
    n--;
} while (swapped);




Your method is limited to arrays of integers. If you compare two
array elements with

if ([muArrRaw[j] compare:muArrRaw[j+1]] == NSOrderedDescending) { ... }


instead then it applies to all element types which have a compare:
method (e.g. NSNumber, NSString, NSDate ...).

Even more general, you can add a comparator argument, as suggested in this
answer:


My own method for sorting numbers in array