Quelques méthodes d'ensemble de différences et comparaison des performances en PHP

En programmation, vous devez toujours traiter certaines données, comme prendre la différence entre deux tableaux donnés. Bien qu'il existe de nombreuses méthodes d'implémentation, laquelle est la plus performante pour trouver l'ensemble des différences ? Aujourd'hui, nous allons partager un exemple de recherche d'un ensemble de différences et comment optimiser les performances de notre code.

La question est la suivante : on vous donne deux tableaux de 5000 éléments chacun, et vous calculez leur ensemble de différences - pour parler franchement, il s'agit d'utiliser PHP et l'algorithme que vous pensez être le meilleur pour implémenter le array_diff algorithme. Lorsque j'ai reçu cette question pour la première fois, j'ai trouvé qu'elle était très simple, alors j'en ai écrit une "avec désinvolture" en me basant sur mon expérience passée :

 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; 
}

Bien que la mise en œuvre soit possible, j'ai trouvé que le l'efficacité de cette fonction est épouvantable. J'ai donc reconsidéré et optimisé l'algorithme. La deuxième fonction ressemblait à ceci :

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; 
}

Eh bien, cette fois, elle est presque aussi rapide que la fonction array_diff d'origine. Mais existe-t-il une méthode plus optimisée ? À partir d'un article sur ChinaUnix (désolé, j'ai triché), j'ai découvert que PHP peut en fait être écrit comme ceci :

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; 
}

L'efficacité de cette fonction est incroyable, encore plus rapide que la fonction array_diff d'origine. En enquêtant sur la raison, j'ai trouvé l'explication :

Parce que les clés sont organisées par HASH, la recherche est très rapide

Et la valeur est uniquement stockée ; par l'organisation Key. Il n'y a pas d'index lui-même et chaque recherche est parcourue. Résumé

Bien qu'il s'agisse d'une petite astuce du langage PHP, lorsqu'il s'agit de parcourir et de comparer les valeurs d'un tableau, si vous avez besoin de comparer la valeur, l'inverser avec la clé est en effet plus efficace que la valeur habituelle- comparaison de valeur.

Par exemple, la fonction deux ci-dessus doit appeler la fonction in_array et doit effectuer une boucle pour déterminer si elle se trouve dans la fonction tandis que la fonction trois détermine uniquement si la clé ; existe dans le tableau. Couplé aux différentes méthodes d'indexation organisationnelle des clés et des valeurs des tableaux, il est tout à fait compréhensible que l'efficacité soit plus élevée qu'on ne l'imaginait.

<?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"; 
?>

Recommandations associées :

algorithme php Fractionner un tableau sans array_chunk()_Tutoriel PHP

Fonctions d'union, d'intersection et de différence des tableaux

Résumé de la méthode de tri des tableaux PHP

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!