Optimisation des performances de tri des tableaux multidimensionnels PHP : du code à l'algorithme

L'optimisation des performances de tri des tableaux multidimensionnels PHP peut être améliorée grâce au code et à l'algorithme. L'optimisation du code inclut l'utilisation de fonctions de tri et de comparaison auto-écrites pour éviter les comparaisons et les copies excessives. L'optimisation des algorithmes implique des algorithmes de tri rapide et de tri par fusion. Le tri rapide convient aux grands tableaux, tandis que le tri par fusion convient à tout type de données. L'exemple de code montre comment trier un tableau avec des éléments enfants à l'aide de ces deux algorithmes, un tri rapide par identifiant et un tri par fusion par nom.

Optimisation des performances de tri des tableaux multidimensionnels PHP : code et algorithme

Introduction

Un tableau multidimensionnel est une structure de données courante en PHP et est très utile lors du traitement de données complexes. Cependant, des problèmes de performances surviennent lorsque vous devez trier des tableaux multidimensionnels. Cet article explorera l'optimisation des performances du tri de tableaux multidimensionnels en PHP et fournira des solutions tant du point de vue du code que de l'algorithme.

Optimisation du code

Utilisez usort et la fonction de comparaison auto-écriteusort 和自写比较函数

相比于内置的 sort 函数，usort

Par rapport à la fonction sort intégrée, le usort fonction code> A une plus grande flexibilité car elle vous permet d'utiliser des fonctions de comparaison personnalisées pour trier les éléments du tableau. Les fonctions de comparaison auto-écrites peuvent être personnalisées pour vos besoins de tri spécifiques, rendant le tri plus efficace. <strong><pre class='brush:php;toolbar:false;'>&lt;?php function compare($a, $b) { return $a['key'] &lt;=&gt; $b['key']; } usort($array, 'compare');</pre></strong>

Évitez les comparaisons et les copies excessives

Pendant le processus de tri, les éléments du tableau seront comparés et copiés à plusieurs reprises. Les performances peuvent être améliorées en réduisant le nombre de comparaisons et de copies inutiles. Les conseils suivants peuvent vous aider à éviter ces opérations :
Utilisez le tri par fusion :
• Le tri par fusion est un algorithme diviser pour régner qui réduit le nombre de comparaisons inutiles.
Créer une copie à trier :

Trier une copie du tableau pour éviter de modifier le tableau d'origine.

Optimisation de l'algorithme

Utiliser le tri rapide :

Le tri rapide est un algorithme de tri efficace, particulièrement adapté aux grands tableaux. Cela fonctionne en divisant le tableau en parties plus petites et en triant les parties de manière récursive.

<?php
function quickSort($array) {
  if (count($array) <= 1) {
    return $array;
  }
  $pivot = $array[0];
  $left = array_filter($array, function ($item) use ($pivot) {
    return $item < $pivot;
  });
  $right = array_filter($array, function ($item) use ($pivot) {
    return $item >= $pivot;
  });
  return array_merge(quickSort($left), [$pivot], quickSort($right));
}

Utilisez le tri par fusion :

Le tri par fusion est également un algorithme de tri efficace qui fonctionne sur tout type de données. Cela fonctionne en divisant récursivement le tableau en parties plus petites, en triant les parties, puis en les fusionnant.

<?php
function mergeSort($array) {
  if (count($array) <= 1) {
    return $array;
  }
  $mid = intdiv(count($array), 2);
  $left = mergeSort(array_slice($array, 0, $mid));
  $right = mergeSort(array_slice($array, $mid));
  return merge($left, $right);
}

function merge($left, $right) {
  $result = [];
  while (count($left) > 0 && count($right) > 0) {
    if ($left[0] <= $right[0]) {
      $result[] = array_shift($left);
    } else {
      $result[] = array_shift($right);
    }
  }
  return array_merge($result, $left, $right);
}

Cas pratique

Ce qui suit est un cas pratique montrant comment utiliser le tri rapide et le tri par fusion pour trier un tableau multidimensionnel avec des sous-éléments :

<?php
$array = [
  ['id' => 1, 'name' => 'John'],
  ['id' => 3, 'name' => 'Alice'],
  ['id' => 2, 'name' => 'Bob']
];

// 使用快速排序按 id 排序
$quickSortedArray = quickSort($array);

// 使用归并排序按 name 排序
$mergeSortedArray = mergeSort($array);

// 输出排序后的数组
print_r($quickSortedArray);
print_r($mergeSortedArray);

Sortie : 🎜🎜

Array
(
    [0] => Array
        (
            [id] => 1
            [name] => John
        )

    [1] => Array
        (
            [id] => 2
            [name] => Bob
        )

    [2] => Array
        (
            [id] => 3
            [name] => Alice
        )

)

Array
(
    [0] => Array
        (
            [id] => 2
            [name] => Bob
        )

    [1] => Array
        (
            [id] => 1
            [name] => John
        )

    [2] => Array
        (
            [id] => 3
            [name] => Alice
        )

)

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!