Einige Differenzsatzmethoden und Leistungsvergleich in PHP

Beim Programmieren müssen Sie immer einige Daten verarbeiten, beispielsweise die Differenz zwischen zwei gegebenen Arrays ermitteln. Obwohl es viele Implementierungsmethoden gibt, welche Methode bietet eine bessere Leistung beim Ermitteln der Differenzmenge? Heute werden wir ein Beispiel für das Finden eines Differenzsatzes und die Optimierung der Leistung unseres Codes vorstellen.

Die Frage lautet wie folgt: Sie erhalten zwei Arrays mit jeweils 5000 Elementen und berechnen deren Differenzmenge. Um es ganz klar auszudrücken: Sie verwenden PHP und den Algorithmus, der Ihrer Meinung nach der beste ist, um array_diff zu implementieren Algorithmus. Als ich diese Frage zum ersten Mal erhielt, stellte ich fest, dass sie sehr einfach war, und schrieb daher eine „beiläufig“ basierend auf meinen bisherigen Erfahrungen:

 function array_diff($array_1, $array_2) { 
    $diff = array(); 
    foreach ($array_1 as $k => $v1) { 
        $flag = false; 
        foreach ($array_2 as $v2) { 
            if ($flag = ($v1 == $v2)) { 
                break; 
            } 
        } 
        if (!$flag) { 
            $diff[$k] = $v1; 
        } 
    } 
    return $diff; 
}

Obwohl die Implementierung möglich ist, stellte ich fest, dass die Effizienz davon Funktion ist schrecklich. Also habe ich den Algorithmus noch einmal überdacht und optimiert. Die zweite Funktion sah so aus:

function array_diff($array_1, $array_2) { 
    foreach ($array_1 as $key => $item) { 
        if (in_array($item, $array_2, true)) { 
            unset($array_1[$key]); 
        } 
    } 
    return $array_1; 
}

Nun, dieses Mal ist sie fast so schnell wie die ursprüngliche array_diff-Funktion. Aber gibt es einen optimierteren Weg? Aus einem Artikel über ChinaUnix (tut mir leid, ich habe geschummelt) habe ich herausgefunden, dass PHP tatsächlich so geschrieben werden kann:

function array_diff($array_1, $array_2) { 
    $array_2 = array_flip($array_2); 
    foreach ($array_1 as $key => $item) { 
        if (isset($array_2[$item])) { 
            unset($array_1[$key]); 
        } 
     } 
    return $array_1; 
}

Die Effizienz dieser Funktion ist erstaunlich, sogar schneller als die ursprüngliche array_diff-Funktion. Als ich den Grund untersuchte, fand ich die Erklärung:

Da die Schlüssel nach HASH organisiert sind, ist die Suche sehr schnell

Und der Wert wird nur gespeichert von der Schlüsselorganisation Es gibt keinen Index selbst und jede Suche wird durchlaufen. Zusammenfassung

Obwohl dies ein kleiner Trick der PHP-Sprache ist, ist das Umkehren mit dem Schlüssel beim Durchlaufen und Vergleichen von Array-Werten tatsächlich effizienter als der übliche Wert, wenn Sie den Wert vergleichen müssen. zu-Wert-Vergleich.

Zum Beispiel muss die Funktion zwei oben die Funktion in_array aufrufen und eine Schleife durchlaufen, um festzustellen, ob sie sich innerhalb der Funktion befindet, während die Funktion drei nur bestimmt, ob der Schlüssel vorhanden ist existiert im Array. In Verbindung mit den unterschiedlichen organisatorischen Indizierungsmethoden von Array-Schlüsseln und -Werten ist es sehr verständlich, dass die Effizienz höher ist als gedacht.

<?php 
function microtime_float() { 
    list($usec, $sec) = explode(" ", microtime()); 
    return ((float)$usec + (float)$sec); 
} 
function array_diff2($array_1, $array_2) { 
    $diff = array(); 
    foreach ($array_1 as $k => $v1) { 
        $flag = false; 
        foreach ($array_2 as $v2) { 
            if ($flag = ($v1 == $v2)) { 
                break; 
            } 
        } 
        if (!$flag) { 
            $diff[$k] = $v1; 
        } 
    } 
    return $diff; 
} 
function array_diff3($array_1, $array_2) { 
    foreach ($array_1 as $key => $item) { 
        if (in_array($item, $array_2, true)) { 
            unset($array_1[$key]); 
        } 
    } 
    return $array_1; 
} 
function array_diff4($array_1, $array_2) { 
    $array_2 = array_flip($array_2); 
    foreach ($array_1 as $key => $item) { 
        if (isset($array_2[$item])) { 
            unset($array_1[$key]); 
        } 
     } 
    return $array_1; 
} 
////////////////////////////// 
for($i = 0, $ary_1 = array(); $i < 5000; $i++) { 
    $ary_1[] = rand(100, 999); 
} 
for($i = 0, $ary_2 = array(); $i < 5000; $i++) { 
    $ary_2[] = rand(100, 999); 
} 
header("Content-type: text/plain;charset=utf-8"); 
$time_start = microtime_float(); 
array_diff($ary_1, $ary_2); 
echo "函数 array_diff 运行" . (microtime_float() - $time_start) . " 秒\n"; 
$time_start = microtime_float(); 
array_diff2($ary_1, $ary_2); 
echo "函数 array_diff2 运行" . (microtime_float() - $time_start) . " 秒\n"; 
$time_start = microtime_float(); 
array_diff3($ary_1, $ary_2); 
echo "函数 array_diff3 运行" . (microtime_float() - $time_start) . " 秒\n"; 
$time_start = microtime_float(); 
array_diff4($ary_1, $ary_2); 
echo "函数 array_diff4 运行" . (microtime_float() - $time_start) . " 秒\n"; 
?>

Verwandte Empfehlungen:

php-Algorithmus Teilen Sie ein Array ohne array_chunk()_PHP-Tutorial

Vereinigungs-, Schnitt- und Differenzfunktionen von Arrays

Zusammenfassung der PHP-Array-Sortiermethode

Das obige ist der detaillierte Inhalt vonEinige Differenzsatzmethoden und Leistungsvergleich in PHP. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!