Den kleinsten und größten Wert in NSArray von NSNumbers finden

Wenn Ausführungsgeschwindigkeit (nicht Programmierung) wichtig ist, dann eine explizite Schleife ist die Schnellste. Ich habe die folgenden tests mit einer Reihe von 1000000 Zufallszahlen:

Version 1: Sortieren Sie das array:

NSArray *sorted1 = [numbers sortedArrayUsingSelector:@selector(compare:)];
//1.585 seconds

Version 2: Key-value-coding, mit "doubleValue":

NSNumber *max=[numbers valueForKeyPath:@"@max.doubleValue"];
NSNumber *min=[numbers valueForKeyPath:@"@min.doubleValue"];
//0.778 seconds

Version 3: der Schlüssel-Wert-Codierung, die mit "selbst":

NSNumber *max=[numbers valueForKeyPath:@"@max.self"];
NSNumber *min=[numbers valueForKeyPath:@"@min.self"];
//0.390 seconds

Version 4: Explizite Schleife:

float xmax = -MAXFLOAT;
float xmin = MAXFLOAT;
for (NSNumber *num in numbers) {
    float x = num.floatValue;
    if (x < xmin) xmin = x;
    if (x > xmax) xmax = x;
}
//0.019 seconds

Version 5: Block-enumeration:

__block float xmax = -MAXFLOAT;
__block float xmin = MAXFLOAT;
[numbers enumerateObjectsUsingBlock:^(NSNumber *num, NSUInteger idx, BOOL *stop) {
    float x = num.floatValue;
    if (x < xmin) xmin = x;
    if (x > xmax) xmax = x;
}];
//0.024 seconds

Dem test-Programm erstellt ein array mit 1000000 Zufallszahlen, und wendet dann alle Sortieren
Techniken, die auf das gleiche array. Die Zeiten oben sind der output von einem Lauf, aber ich mache ca 20 läuft mit sehr ähnlichen Ergebnissen in jedem Lauf. Ich habe auch die Reihenfolge geändert, in der die 5 Sortierverfahren angewendet werden, um auszuschließen, caching-Effekte.

Update: ich habe jetzt eine (hoffentlich) bessere test-Programm. Der vollständige Quellcode ist hier: https://gist.github.com/anonymous/5356982. Die durchschnittlichen Zeiten für die Sortierung ein
array mit 1000000 Zufallszahlen (in Sekunden, auf einen 3.1 GHz Core i5 iMac, release kompilieren):

Sortierung 1.404 
KVO1 1.087 
KVO2 0.367 
Schnell enum 0.017 
Block enum 0.021 

Update 2: Wie man sehen kann, fallen die Aufzählung ist schneller als der block enumeration (das ist auch hier gesagt: http://blog.bignerdranch.com/2337-incremental-arrayification/).

EDIT: Der folgenden ist völlig falsch, weil ich vergessen habe zu initialisieren das Objekt als lock, Hot Licks richtig bemerkt, so dass keine Synchronisation durchgeführt.
Und mit lock = [[NSObject alloc] init]; die gleichzeitige Aufzählung ist so langsam
das wage ich nicht zu zeigen das Ergebnis. Vielleicht ein schneller Synchronisierungsmechanismus könnte
Hilfe ...)

Dies ändert sich dramatisch, wenn Sie das NSEnumerationConcurrent option, um die
block enumeration:

__block float xmax = -MAXFLOAT;
__block float xmin = MAXFLOAT;
id lock;
[numbers enumerateObjectsWithOptions:NSEnumerationConcurrent usingBlock:^(NSNumber *num, NSUInteger idx, BOOL *stop) {
    float x = num.floatValue;
    @synchronized(lock) {
        if (x < xmin) xmin = x;
        if (x > xmax) xmax = x;
    }
}];

Gleichzeitige enum-0.009 

so ist es etwa doppelt so schnell wie fast-enumeration. Das Ergebnis ist wahrscheinlich nicht repräsentativ
denn es hängt von der Anzahl der verfügbaren threads. Aber interessant auf jeden Fall! Beachten Sie, dass ich
der am einfachsten zu bedienende Synchronisations-Methode, die vielleicht nicht die schnellsten.

InformationsquelleAutor der Antwort Martin R

Sortieren. nehmen Sie das erste und das Letzte element.

btw: you cant store schwimmt in einem NSArray, müssen Sie wickeln Sie Sie in NSNumber-Objekte.

NSArray *numbers = @[@2.1, @8.1, @5.0, @.3];
numbers = [numbers sortedArrayUsingSelector:@selector(compare:)];

float min = [numbers[0] floatValue];
float max = [[numbers lastObject] floatValue];

InformationsquelleAutor der Antwort vikingosegundo

Einfach gemacht

NSArray *numbers = @[@2.1, @8.1, @5.0, @.3];
numbers = [numbers sortedArrayUsingSelector:@selector(compare:)];

float min = [numbers[0] floatValue];
float max = [[numbers lastObject] floatValue];

NSLog(@"MIN%f",min);
NSLog(@"MAX%f",max);

InformationsquelleAutor der Antwort Frank