Como posso reverter um NSArray no Objective-C?

Eu preciso reverter o meu NSArray.

Como um exemplo:

[1,2,3,4,5] deve se tornar: [5,4,3,2,1]

Qual é a melhor maneira de conseguir isso?

Para obter uma cópia invertida de uma matriz, observe a solução de danielpunkass usando reverseObjectEnumerator.

Para reverter uma matriz mutável, você pode adicionar a seguinte categoria ao seu código:

@implementation NSMutableArray (Reverse)

- (void)reverse {
    if ([self count] <= 1)
        return;
    NSUInteger i = 0;
    NSUInteger j = [self count] - 1;
    while (i < j) {
        [self exchangeObjectAtIndex:i
                  withObjectAtIndex:j];

        i++;
        j--;
    }
}

@end

Existe uma solução muito mais fácil, se você tirar proveito do reverseObjectEnumeratormétodo interno ativado NSArraye do allObjectsmétodo de NSEnumerator:

NSArray* reversedArray = [[startArray reverseObjectEnumerator] allObjects];

allObjectsestá documentado como retornando uma matriz com os objetos que ainda não foram atravessados nextObject, em ordem:

Essa matriz contém todos os demais objetos do enumerador em ordem enumerada .

Alguns benchmarks

1. reverseObjectEnumerator allObjects

Este é o método mais rápido:

NSArray *anArray = @[@"aa", @"ab", @"ac", @"ad", @"ae", @"af", @"ag",
        @"ah", @"ai", @"aj", @"ak", @"al", @"am", @"an", @"ao", @"ap", @"aq", @"ar", @"as", @"at",
        @"au", @"av", @"aw", @"ax", @"ay", @"az", @"ba", @"bb", @"bc", @"bd", @"bf", @"bg", @"bh",
        @"bi", @"bj", @"bk", @"bl", @"bm", @"bn", @"bo", @"bp", @"bq", @"br", @"bs", @"bt", @"bu",
        @"bv", @"bw", @"bx", @"by", @"bz", @"ca", @"cb", @"cc", @"cd", @"ce", @"cf", @"cg", @"ch",
        @"ci", @"cj", @"ck", @"cl", @"cm", @"cn", @"co", @"cp", @"cq", @"cr", @"cs", @"ct", @"cu",
        @"cv", @"cw", @"cx", @"cy", @"cz"];

NSDate *methodStart = [NSDate date];

NSArray *reversed = [[anArray reverseObjectEnumerator] allObjects];

NSDate *methodFinish = [NSDate date];
NSTimeInterval executionTime = [methodFinish timeIntervalSinceDate:methodStart];
NSLog(@"executionTime = %f", executionTime);

Resultado: executionTime = 0.000026

2. Iterando sobre um reverseObjectEnumerator

Isso fica entre 1,5x e 2,5x mais lento:

NSDate *methodStart = [NSDate date];
NSMutableArray *array = [NSMutableArray arrayWithCapacity:[anArray count]];
NSEnumerator *enumerator = [anArray reverseObjectEnumerator];
for (id element in enumerator) {
    [array addObject:element];
}
NSDate *methodFinish = [NSDate date];
NSTimeInterval executionTime = [methodFinish timeIntervalSinceDate:methodStart];
NSLog(@"executionTime = %f", executionTime);

Resultado: executionTime = 0.000071

3. selectedArrayUsingComparator

Isso fica entre 30x e 40x mais lento (sem surpresas aqui):

NSDate *methodStart = [NSDate date];
NSArray *reversed = [anArray sortedArrayUsingComparator: ^(id obj1, id obj2) {
    return [anArray indexOfObject:obj1] < [anArray indexOfObject:obj2] ? NSOrderedDescending : NSOrderedAscending;
}];

NSDate *methodFinish = [NSDate date];
NSTimeInterval executionTime = [methodFinish timeIntervalSinceDate:methodStart];
NSLog(@"executionTime = %f", executionTime);

Resultado: executionTime = 0.001100

Assim [[anArray reverseObjectEnumerator] allObjects]é o vencedor claro quando se trata de velocidade e facilidade.

O DasBoot tem a abordagem correta, mas há alguns erros em seu código. Aqui está um trecho de código completamente genérico que reverterá qualquer NSMutableArray no local:

/* Algorithm: swap the object N elements from the top with the object N 
 * elements from the bottom. Integer division will wrap down, leaving 
 * the middle element untouched if count is odd.
 */
for(int i = 0; i < [array count] / 2; i++) {
    int j = [array count] - i - 1;

    [array exchangeObjectAtIndex:i withObjectAtIndex:j];
}

Você pode agrupar isso em uma função C ou, para pontos de bônus, use categorias para adicioná-lo ao NSMutableArray. (Nesse caso, 'array' se tornaria 'self'.) Você também pode otimizá-lo atribuindo [array count]uma variável antes do loop e usando essa variável, se desejar.

Se você possui apenas um NSArray regular, não há como revertê-lo, pois o NSArrays não pode ser modificado. Mas você pode fazer uma cópia invertida:

NSMutableArray * copy = [NSMutableArray arrayWithCapacity:[array count]];

for(int i = 0; i < [array count]; i++) {
    [copy addObject:[array objectAtIndex:[array count] - i - 1]];
}

Ou use este pequeno truque para fazer isso em uma linha:

NSArray * copy = [[array reverseObjectEnumerator] allObjects];

Se você quiser fazer um loop ao longo de uma matriz para trás, poderá usar um loop for/ , mas provavelmente será um pouco mais eficiente :in[array reverseObjectEnumerator]-enumerateObjectsWithOptions:usingBlock:

[array enumerateObjectsWithOptions:NSEnumerationReverse
                        usingBlock:^(id obj, NSUInteger idx, BOOL *stop) {
    // This is your loop body. Use the object in obj here. 
    // If you need the index, it's in idx.
    // (This is the best feature of this method, IMHO.)
    // Instead of using 'continue', use 'return'.
    // Instead of using 'break', set '*stop = YES' and then 'return'.
    // Making the surrounding method/block return is tricky and probably
    // requires a '__block' variable.
    // (This is the worst feature of this method, IMHO.)
}];

( Observação : substancialmente atualizado em 2014, com mais cinco anos de experiência da Fundação, um novo recurso do Objective-C ou dois e algumas dicas dos comentários.)

Depois de revisar as respostas dos outros acima e encontrar a discussão de Matt Gallagher aqui

Eu proponho isso:

NSMutableArray * reverseArray = [NSMutableArray arrayWithCapacity:[myArray count]]; 

for (id element in [myArray reverseObjectEnumerator]) {
    [reverseArray addObject:element];
}

Como Matt observa:

No caso acima, você pode se perguntar se - [NSArray reverseObjectEnumerator] seria executado em todas as iterações do loop - potencialmente diminuindo a velocidade do código. <...>

Pouco tempo depois, ele responde assim:

<...> A expressão "coleção" é avaliada apenas uma vez, quando o loop for começa. Esse é o melhor caso, pois você pode colocar com segurança uma função cara na expressão "coleção" sem afetar o desempenho por loop do loop por iteração.

As categorias de Georg Schölly são muito agradáveis. No entanto, para NSMutableArray, o uso de NSUIntegers para os índices resulta em uma falha quando a matriz está vazia. O código correto é:

@implementation NSMutableArray (Reverse)

- (void)reverse {
    NSInteger i = 0;
    NSInteger j = [self count] - 1;
    while (i < j) {
        [self exchangeObjectAtIndex:i
                  withObjectAtIndex:j];

        i++;
        j--;
    }
}

@end

A maneira mais eficiente de enumerar uma matriz ao contrário:

Use enumerateObjectsWithOptions:NSEnumerationReverse usingBlock. Usando o benchmark de @ JohannesFahrenkrug acima, isso foi concluído 8 vezes mais rápido que [[array reverseObjectEnumerator] allObjects];:

NSDate *methodStart = [NSDate date];

[anArray enumerateObjectsWithOptions:NSEnumerationReverse usingBlock:^(id obj, NSUInteger idx, BOOL *stop) {
    //
}];

NSDate *methodFinish = [NSDate date];
NSTimeInterval executionTime = [methodFinish timeIntervalSinceDate:methodStart];
NSLog(@"executionTime = %f", executionTime);

NSMutableArray *objMyObject = [NSMutableArray arrayWithArray:[self reverseArray:objArrayToBeReversed]];

// Function reverseArray 
-(NSArray *) reverseArray : (NSArray *) myArray {   
    return [[myArray reverseObjectEnumerator] allObjects];
}

Inverter matriz e fazer um loop através dela:

[[[startArray reverseObjectEnumerator] allObjects] enumerateObjectsUsingBlock:^(id obj, NSUInteger idx, BOOL *stop) {
    ...
}];

Para atualizar isso, no Swift, isso pode ser feito facilmente com:

array.reverse()

Quanto a mim, você considerou como a matriz foi preenchida em primeiro lugar? Eu estava no processo de adicionar MUITOS objetos a uma matriz e decidi inserir cada um no início, empurrando todos os objetos existentes por um. Requer uma matriz mutável, neste caso.

NSMutableArray *myMutableArray = [[NSMutableArray alloc] initWithCapacity:1];
[myMutableArray insertObject:aNewObject atIndex:0];

Ou o Scala-way:

-(NSArray *)reverse
{
    if ( self.count < 2 )
        return self;
    else
        return [[self.tail reverse] concat:[NSArray arrayWithObject:self.head]];
}

-(id)head
{
    return self.firstObject;
}

-(NSArray *)tail
{
    if ( self.count > 1 )
        return [self subarrayWithRange:NSMakeRange(1, self.count - 1)];
    else
        return @[];
}

Existe uma maneira fácil de fazer isso.

    NSArray *myArray = @[@"5",@"4",@"3",@"2",@"1"];
    NSMutableArray *myNewArray = [[NSMutableArray alloc] init]; //this object is going to be your new array with inverse order.
    for(int i=0; i<[myNewArray count]; i++){
        [myNewArray insertObject:[myNewArray objectAtIndex:i] atIndex:0];
    }
    //other way to do it
    for(NSString *eachValue in myArray){
        [myNewArray insertObject:eachValue atIndex:0];
    }

    //in both cases your new array will look like this
    NSLog(@"myNewArray: %@", myNewArray);
    //[@"1",@"2",@"3",@"4",@"5"]

Eu espero que isso ajude.

Não conheço nenhum método embutido. Mas codificar à mão não é muito difícil. Supondo que os elementos da matriz com a qual você está lidando sejam objetos NSNumber do tipo inteiro, e 'arr' seja o NSMutableArray que você deseja reverter.

int n = [arr count];
for (int i=0; i<n/2; ++i) {
  id c  = [[arr objectAtIndex:i] retain];
  [arr replaceObjectAtIndex:i withObject:[arr objectAtIndex:n-i-1]];
  [arr replaceObjectAtIndex:n-i-1 withObject:c];
}

Desde que você começa com um NSArray, é necessário criar a matriz mutável primeiro com o conteúdo do NSArray original ('origArray').

NSMutableArray * arr = [[NSMutableArray alloc] init];
[arr setArray:origArray];

Edit: Fixed n -> n / 2 na contagem de loop e mudou NSNumber para o ID mais genérico devido às sugestões na resposta de Brent.

Se tudo o que você deseja fazer é iterar ao contrário, tente o seguinte:

// iterate backwards
nextIndex = (currentIndex == 0) ? [myArray count] - 1 : (currentIndex - 1) % [myArray count];

Você pode fazer o [myArrayCount] uma vez e salvá-lo em uma variável local (acho que é cara), mas também acho que o compilador fará a mesma coisa com o código descrito acima.

Sintaxe do Swift 3:

let reversedArray = array.reversed()

Tente o seguinte:

for (int i = 0; i < [arr count]; i++)
{
    NSString *str1 = [arr objectAtIndex:[arr count]-1];
    [arr insertObject:str1 atIndex:i];
    [arr removeObjectAtIndex:[arr count]-1];
}

Aqui está uma boa macro que funcionará para NSMutableArray OU NSArray:

#define reverseArray(__theArray) {\
    if ([__theArray isKindOfClass:[NSMutableArray class]]) {\
        if ([(NSMutableArray *)__theArray count] > 1) {\
            NSUInteger i = 0;\
            NSUInteger j = [(NSMutableArray *)__theArray count]-1;\
            while (i < j) {\
                [(NSMutableArray *)__theArray exchangeObjectAtIndex:i\
                                                withObjectAtIndex:j];\
                i++;\
                j--;\
            }\
        }\
    } else if ([__theArray isKindOfClass:[NSArray class]]) {\
        __theArray = [[NSArray alloc] initWithArray:[[(NSArray *)__theArray reverseObjectEnumerator] allObjects]];\
    }\
}

Para usar apenas ligue: reverseArray(myArray);