Liste der Big-O für PHP-Funktionen

Nachdem ich PHP für eine Weile verwendet habe, habe ich festgestellt, dass nicht alle integrierten PHP-Funktionen so schnell sind wie erwartet. Betrachten Sie diese beiden möglichen Implementierungen einer Funktion, die mithilfe eines zwischengespeicherten Arrays von Primzahlen ermittelt, ob eine Zahl eine Primzahl ist.

//very slow for large $prime_array
$prime_array = array( 2, 3, 5, 7, 11, 13, .... 104729, ... );
$result_array = array();
foreach( $prime_array => $number ) {
    $result_array[$number] = in_array( $number, $large_prime_array );
}

//speed is much less dependent on size of $prime_array, and runs much faster.
$prime_array => array( 2 => NULL, 3 => NULL, 5 => NULL, 7 => NULL,
                       11 => NULL, 13 => NULL, .... 104729 => NULL, ... );
foreach( $prime_array => $number ) {
    $result_array[$number] = array_key_exists( $number, $large_prime_array );
}

Dies liegt daran in_array, dass eine lineare Suche O (n) implementiert wird, die sich mit zunehmendem Wachstum linear verlangsamt $prime_array. Wenn die array_key_existsFunktion mit einer Hash-Suche O (1) implementiert wird, die nicht verlangsamt wird, es sei denn, die Hash-Tabelle wird extrem gefüllt (in diesem Fall ist es nur O (n)).

Bisher musste ich die Big-O's durch Ausprobieren entdecken und gelegentlich den Quellcode betrachten . Nun zur Frage ...

Gibt es eine Liste der theoretischen (oder praktischen) großen O-Zeiten für alle * integrierten PHP-Funktionen?

* oder zumindest die interessanten

Zum Beispiel habe ich es sehr schwer , die große O Funktionen aufgelistet vorherzusagen , weil die mögliche Implementierung auf unbekannte Kerndatenstrukturen von PHP ab: array_merge, array_merge_recursive, array_reverse, array_intersect, array_combine, str_replace(mit Array - Eingänge), usw.

Da es so aussieht, als hätte dies noch niemand getan, dachte ich, es wäre eine gute Idee, es irgendwo als Referenz zu haben. Ich bin jedoch gegangen und entweder über Benchmark oder Code-Skimming, um die array_*Funktionen zu charakterisieren . Ich habe versucht, das interessantere Big-O ganz oben zu platzieren. Diese Liste ist nicht vollständig.

Hinweis: Alle Big-O-Werte, die unter der Annahme einer Hash-Suche berechnet wurden, sind O (1), obwohl es sich tatsächlich um O (n) handelt. Der Koeffizient von n ist so niedrig, dass der RAM-Overhead beim Speichern eines ausreichend großen Arrays Sie verletzen würde, bevor die Eigenschaften von Lookup Big-O wirksam werden. Zum Beispiel array_key_existsbeträgt die Differenz zwischen einem Anruf bei N = 1 und N = 1.000.000 ~ 50% Zeitzunahme.

Interessante Punkte :

1. isset/ array_key_existsIst viel schneller als in_arrayundarray_search
2. +(union) ist etwas schneller als array_merge(und sieht besser aus). Aber es funktioniert anders, denken Sie daran.
3. shuffle ist auf der gleichen Big-O-Ebene wie array_rand
4. array_pop/ array_pushist schneller als array_shift/ array_unshiftaufgrund einer Neuindizierungsstrafe

Lookups :

array_key_existsO (n), aber sehr nahe an O (1) - dies liegt an der linearen Abfrage bei Kollisionen, aber da die Wahrscheinlichkeit von Kollisionen sehr gering ist, ist der Koeffizient auch sehr klein. Ich finde, Sie behandeln Hash-Lookups als O (1), um ein realistischeres Big-O zu erhalten. Zum Beispiel ist der Unterschied zwischen N = 1000 und N = 100000 nur etwa 50% langsamer.

isset( $array[$index] )O (n), aber sehr nahe an O (1) - es verwendet dieselbe Suche wie array_key_exists. Da es sich um ein Sprachkonstrukt handelt, wird die Suche zwischengespeichert, wenn der Schlüssel fest codiert ist, was in Fällen, in denen derselbe Schlüssel wiederholt verwendet wird, zu einer Beschleunigung führt.

in_array O (n) - Dies liegt daran, dass eine lineare Suche durch das Array durchgeführt wird, bis der Wert gefunden wird.

array_search O (n) - Es verwendet dieselbe Kernfunktion wie in_array, gibt jedoch einen Wert zurück.

Warteschlangenfunktionen :

array_push O (∑ var_i, für alle i)

array_pop O (1)

array_shift O (n) - Es müssen alle Schlüssel neu indiziert werden

array_unshift O (n + ∑ var_i, für alle i) - es müssen alle Schlüssel neu indiziert werden

Array-Schnittpunkt, Union, Subtraktion :

array_intersect_key Wenn der Schnittpunkt 100% O (Max (param_i_size) * ∑param_i_count für alle i), wenn der Schnittpunkt 0% O schneidet (∑param_i_size für alle i)

array_intersect wenn der Schnittpunkt 100% O (n ^ 2 * ∑param_i_count, für alle i), wenn der Schnittpunkt 0% O schneidet (n ^ 2)

array_intersect_assoc Wenn der Schnittpunkt 100% O (Max (param_i_size) * ∑param_i_count für alle i), wenn der Schnittpunkt 0% O schneidet (∑param_i_size für alle i)

array_diff O (π param_i_size, für alle i) - Das ist das Produkt aller param_sizes

array_diff_key O (∑ param_i_size, für i! = 1) - Dies liegt daran, dass wir nicht über das erste Array iterieren müssen.

array_merge O (∑ array_i, i! = 1) - muss nicht über das erste Array iterieren

+ (union) O (n), wobei n die Größe des 2. Arrays ist (dh array_first + array_second) - weniger Overhead als array_merge, da es nicht neu nummeriert werden muss

array_replace O (∑ array_i, für alle i)

Zufall :

shuffle Auf)

array_rand O (n) - Erfordert eine lineare Abfrage.

Offensichtlicher Big-O :

array_fill Auf)

array_fill_keys Auf)

range Auf)

array_splice O (Versatz + Länge)

array_slice O (Versatz + Länge) oder O (n), wenn Länge = NULL

array_keys Auf)

array_values Auf)

array_reverse Auf)

array_pad O (pad_size)

array_flip Auf)

array_sum Auf)

array_product Auf)

array_reduce Auf)

array_filter Auf)

array_map Auf)

array_chunk Auf)

array_combine Auf)

Ich möchte Eureqa dafür danken, dass es einfach ist, das Big-O der Funktionen zu finden. Es ist ein erstaunliches kostenloses Programm, das die beste Anpassungsfunktion für beliebige Daten finden kann.

BEARBEITEN:

Für diejenigen, die daran zweifeln, dass es sich um PHP-Array-Lookups handelt O(N), habe ich einen Benchmark geschrieben, um dies zu testen (sie sind immer noch effektiv O(1)für die realistischsten Werte).

$tests = 1000000;
$max = 5000001;


for( $i = 1; $i <= $max; $i += 10000 ) {
    //create lookup array
    $array = array_fill( 0, $i, NULL );

    //build test indexes
    $test_indexes = array();
    for( $j = 0; $j < $tests; $j++ ) {
        $test_indexes[] = rand( 0, $i-1 );
    }

    //benchmark array lookups
    $start = microtime( TRUE );
    foreach( $test_indexes as $test_index ) {
        $value = $array[ $test_index ];
        unset( $value );
    }
    $stop = microtime( TRUE );
    unset( $array, $test_indexes, $test_index );

    printf( "%d,%1.15f\n", $i, $stop - $start ); //time per 1mil lookups
    unset( $stop, $start );
}

Die Erklärung für den Fall, den Sie speziell beschreiben, ist, dass assoziative Arrays als Hash-Tabellen implementiert sind. Die Suche nach Schlüssel (und entsprechend array_key_exists) ist also O (1). Arrays werden jedoch nicht nach Wert indiziert. Daher ist die einzige Möglichkeit, im allgemeinen Fall festzustellen, ob ein Wert im Array vorhanden ist, eine lineare Suche. Da gibt es keine Überraschung.

Ich glaube nicht, dass es eine spezifische umfassende Dokumentation der algorithmischen Komplexität von PHP-Methoden gibt. Wenn es jedoch groß genug ist, um den Aufwand zu rechtfertigen, können Sie jederzeit den Quellcode durchsehen .

Sie möchten fast immer issetanstelle von verwenden array_key_exists. Ich schaue nicht auf die Interna, aber ich bin mir ziemlich sicher, dass dies array_key_existsO (N) ist, da es über jeden einzelnen Schlüssel des Arrays iteriert, während issetversucht wird, mit demselben Hash-Algorithmus auf das Element zuzugreifen, der beim Zugriff verwendet wird ein Array-Index. Das sollte O (1) sein.

Ein "Gotcha", auf das Sie achten sollten, ist Folgendes:

$search_array = array('first' => null, 'second' => 4);

// returns false
isset($search_array['first']);

// returns true
array_key_exists('first', $search_array);

Ich war neugierig und habe den Unterschied gemessen:

<?php

$bigArray = range(1,100000);

$iterations = 1000000;
$start = microtime(true);
while ($iterations--)
{
    isset($bigArray[50000]);
}

echo 'is_set:', microtime(true) - $start, ' seconds', '<br>';

$iterations = 1000000;
$start = microtime(true);
while ($iterations--)
{
    array_key_exists(50000, $bigArray);
}

echo 'array_key_exists:', microtime(true) - $start, ' seconds';
?>

is_set:0,132308959961 Sekunden
array_key_exists:2,33202195168 Sekunden

Dies zeigt natürlich keine zeitliche Komplexität, aber es zeigt, wie die beiden Funktionen miteinander verglichen werden.

Vergleichen Sie zum Testen der Zeitkomplexität die Zeit, die zum Ausführen einer dieser Funktionen auf der ersten und der letzten Taste benötigt wird.

Wenn Menschen in der Praxis Probleme mit Schlüsselkollisionen haben, implementieren sie Container mit einer sekundären Hash-Suche oder einem ausgeglichenen Baum. Der ausgeglichene Baum würde O (log n) Worst-Case-Verhalten und O (1) Durchschnitt ergeben. Fall (der Hash selbst). Der Overhead lohnt sich in den meisten praktischen Anwendungen in Speicheranwendungen nicht, aber vielleicht gibt es Datenbanken, die diese Form der gemischten Strategie als Standardfall implementieren.