Comment trier les tableaux et les données en PHP ?

Question

Cette question est destinée à servir de référence concernant les problèmes de tri des tableaux en PHP. Il est facile de penser que votre cas particulier est unique et mérite une nouvelle question, mais la plupart ne sont en réalité que des variations mineures de l'une des solutions proposées sur cette page.

Si votre question a été fermée en double de cette question, veuillez demander à rouvrir votre question uniquement si vous pouvez expliquer pourquoi elle est significativement différente de toutes les questions ci-dessous.

Comment trier un tableau en PHP ?

Comment trier un tableau complexeen PHP ?

Comment trier un tableau d’objets en PHP ?

---

1. Tableau unidimensionnel de base inclus ; Tableaux multidimensionnels, incl. Tableau d'objets ; comprend. Trier un tableau en fonction d'un autre tableau

2. Utilisez le tri SPL

3. Tri stable

Pour une réponse pratique utilisant les fonctions existantes de PHP, voir 1., et pour une réponse académiquement détaillée sur les algorithmes de tri (que les fonctions PHP implémentent et dont vous pourriez pourriez avoir besoin dans des cas très, très complexes), voir 2.

Answer 1

D'accord, decezea couvert la plupart des méthodes de base, je vais essayer d'examiner d'autres types de tri

Trier avec SPL

SplHeap

class SimpleHeapSort extends SplHeap {
    public function compare($a, $b) {
        return strcmp($a, $b);
    }
}

// Let's populate our heap here (data of 2009)
$heap = new SimpleHeapSort();
$heap->insert("a");
$heap->insert("b");
$heap->insert("c");

echo implode(PHP_EOL, iterator_to_array($heap));

Sortie

c
b
a

SplMaxHeap

La classe SplMaxHeap fournit la fonctionnalité principale du tas, en gardant la valeur maximale en haut.

$heap = new SplMaxHeap();
$heap->insert(1);
$heap->insert(2);
$heap->insert(3);

SplMinHeap

$heap = new SplMinHeap ();
$heap->insert(3);
$heap->insert(1);
$heap->insert(2);

Autres types de tri

Tri à bulles

Extrait deArticle Wikipédia sur le tri à bulles :

function bubbleSort(array $array) {
    $array_size = count($array);
    for($i = 0; $i < $array_size; $i ++) {
        for($j = 0; $j < $array_size; $j ++) {
            if ($array[$i] < $array[$j]) {
                $tem = $array[$i];
                $array[$i] = $array[$j];
                $array[$j] = $tem;
            }
        }
    }
    return $array;
}

Sélectionner le tri

Extrait de Article Wikipédia sur le tri par sélection :

function selectionSort(array $array) {
    $length = count($array);
    for($i = 0; $i < $length; $i ++) {
        $min = $i;
        for($j = $i + 1; $j < $length; $j ++) {
            if ($array[$j] < $array[$min]) {
                $min = $j;
            }
        }
        $tmp = $array[$min];
        $array[$min] = $array[$i];
        $array[$i] = $tmp;
    }
    return $array;
}

Tri par insertion

Extrait de Article Wikipédia sur le tri par insertion :

function insertionSort(array $array) {
    $count = count($array);
    for($i = 1; $i < $count; $i ++) {

        $j = $i - 1;
        // second element of the array
        $element = $array[$i];
        while ( $j >= 0 && $array[$j] > $element ) {
            $array[$j + 1] = $array[$j];
            $array[$j] = $element;
            $j = $j - 1;
        }
    }
    return $array;
}

Tri des collines

Extrait deArticle Wikipédia sur Shellsort :

function shellSort(array $array) {
    $gaps = array(
            1,
            2,
            3,
            4,
            6
    );
    $gap = array_pop($gaps);
    $length = count($array);
    while ( $gap > 0 ) {
        for($i = $gap; $i < $length; $i ++) {
            $tmp = $array[$i];
            $j = $i;
            while ( $j >= $gap && $array[$j - $gap] > $tmp ) {
                $array[$j] = $array[$j - $gap];
                $j -= $gap;
            }
            $array[$j] = $tmp;
        }
        $gap = array_pop($gaps);
    }
    return $array;
}

Tri des peignes

Extrait deArticle Wikipédia sur le tri par peigne :

function combSort(array $array) {
    $gap = count($array);
    $swap = true;
    while ( $gap > 1 || $swap ) {
        if ($gap > 1)
            $gap /= 1.25;
        $swap = false;
        $i = 0;
        while ( $i + $gap < count($array) ) {
            if ($array[$i] > $array[$i + $gap]) {
                // swapping the elements.
                list($array[$i], $array[$i + $gap]) = array(
                        $array[$i + $gap],
                        $array[$i]
                );
                $swap = true;
            }
            $i ++;
        }
    }
    return $array;
}

Fusionner le tri

De Article Wikipédia sur le tri par fusion :

function mergeSort(array $array) {
    if (count($array) <= 1)
        return $array;

    $left = mergeSort(array_splice($array, floor(count($array) / 2)));
    $right = mergeSort($array);

    $result = array();

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

    while ( count($right) > 0 )
        array_push($result, array_shift($right));

    return $result;
}

Tri rapide

Extrait de Article Wikipédia sur le tri rapide :

function quickSort(array $array) {
    if (count($array) == 0) {
        return $array;
    }
    $pivot = $array[0];
    $left = $right = array();
    for($i = 1; $i < count($array); $i ++) {
        if ($array[$i] < $pivot) {
            $left[] = $array[$i];
        } else {
            $right[] = $array[$i];
        }
    }
    return array_merge(quickSort($left), array(
            $pivot
    ), quickSort($right));
}

Organiser et trier

Extrait de Article Wikipédia sur le tri :

function permutationSort($items, $perms = array()) {
    if (empty($items)) {
        if (inOrder($perms)) {
            return $perms;
        }
    } else {
        for($i = count($items) - 1; $i >= 0; -- $i) {
            $newitems = $items;
            $newperms = $perms;
            list($foo) = array_splice($newitems, $i, 1);
            array_unshift($newperms, $foo);
            $res = permutationSort($newitems, $newperms);
            if ($res) {
                return $res;
            }
        }
    }
}

function inOrder($array) {
    for($i = 0; $i < count($array); $i ++) {
        if (isset($array[$i + 1])) {
            if ($array[$i] > $array[$i + 1]) {
                return False;
            }
        }
    }
    return True;
}

Tri Radix

Extrait de Article Wikipédia sur le tri par base :

// Radix Sort for 0 to 256
function radixSort($array) {
    $n = count($array);
    $partition = array();

    for($slot = 0; $slot < 256; ++ $slot) {
        $partition[] = array();
    }

    for($i = 0; $i < $n; ++ $i) {
        $partition[$array[$i]->age & 0xFF][] = &$array[$i];
    }

    $i = 0;

    for($slot = 0; $slot < 256; ++ $slot) {
        for($j = 0, $n = count($partition[$slot]); $j < $n; ++ $j) {
            $array[$i ++] = &$partition[$slot][$j];
        }
    }
    return $array;
}

Answer 2

Tableau unidimensionnel de base

$array = array(3, 5, 2, 8);

Fonctions de tri applicables :

• 排序
• 排序
• 分类
• 排序
• natsort
• natcasesort
• ksort
• krsort

La seule différence entre eux est de savoir s'il faut conserver l'association clé-valeur ("a”函数），是否按从低到高排序或反向排序（“r” >”），是否对值或键进行排序（“k”）以及如何比较值（“nat" vs. normal). Voir http://php.net/manual/en/array.sorting.php pour un aperçu et un lien vers plus de détails.

Tableaux multidimensionnels, y compris les tableaux d'objets

$array = array(
    array('foo' => 'bar', 'baz' => 42),
    array('foo' => ...,   'baz' => ...),
    ...
);

Si vous souhaitez appuyer sur la paire de touches "foo" de chaque entrée $array进行排序，则需要一个自定义比较函数。上面的 sort et les fonctions associées fonctionnent sur des valeurs simples qu'elles savent comparer et trier. PHP ne "sait" pas simplement comment gérer les valeurs complexes comme array('foo' => 'bar', 'baz' => 42);

Pour ce faire, vous devez créer une fonction de comparaison. Cette fonction accepte deux éléments et si les éléments sont considérés comme égaux, elle doit renvoyer 0；如果第一个值较低，则必须返回低于 0 的值；如果认为第一个值低于 0，则必须返回高于 0 的值 si la première valeur est supérieure. C'est tout ce qu'il faut :

function cmp(array $a, array $b) {
    if ($a['foo'] < $b['foo']) {
        return -1;
    } else if ($a['foo'] > $b['foo']) {
        return 1;
    } else {
        return 0;
    }
}

En général, vous souhaiterez utiliser une fonction anonyme comme rappel. Si vous souhaitez utiliser des méthodes ou des méthodes statiques, consultez Autres façons de spécifier des rappels en PHP.

Ensuite, vous pouvez utiliser l'une des fonctions suivantes :

• usort
• uasort
• uksort

Encore une fois, ils diffèrent uniquement selon que les associations clé-valeur sont préservées et si elles sont triées par valeur ou par clé. Veuillez lire leur documentation pour plus de détails.

Exemple d'utilisation :

usort($array, 'cmp');

usort 将从数组中取出两项并用它们调用您的 cmp 函数。因此 cmp() 将以 $a 的形式调用 array('foo' => 'bar', 'baz' => 42)和 $b 作为另一个 array('foo' => ..., 'baz' => ...)。然后该函数返回到 usort 哪个值更大或者它们是否相等。 usort 重复此过程，为 $a 和 $b 传递不同的值，直到数组排序完毕。 cmp 函数将被调用多次，至少与 $array 中的值一样多，并且值的不同组合每次代码>$a和$b.

Pour vous habituer à cette idée, essayez ce qui suit :

function cmp($a, $b) {
    echo 'cmp called with $a:', PHP_EOL;
    var_dump($a);
    echo 'and $b:', PHP_EOL;
    var_dump($b);
}

Tout ce que vous avez à faire est de définir une manière personnalisée de comparer deux éléments et c'est tout ce dont vous avez besoin. Cela fonctionne pour une variété de valeurs.

À propos, cela fonctionne avec toutes les valeurs, qui ne doivent pas nécessairement être des tableaux complexes. Vous pouvez également comparer de simples tableaux de nombres si vous souhaitez effectuer une comparaison personnalisée.

sort Le tri par référence ne retournera rien d'utile !

Notez que les tableaux sont triés sur place, vous n'avez pas besoin d'attribuer la valeur de retour à quoi que ce soit. $array = sort($array) 会将数组替换为 true，而不是排序后的数组。只需 sort($array); C'est tout.

Comparaison de numéros personnalisés

Si vous souhaitez trier par touches numériques baz, il vous suffit de :

function cmp(array $a, array $b) {
    return $a['baz'] - $b['baz'];
}

Grâce au pouvoir des math, cela renverra une valeur < 0、0 或 > 0, en fonction de $a 是否小于、等于或大于 $b.

Notez que cela est vrai pour la valeur de retour float 值不起作用，因为它们会被简化为 int 并失去精度。请改用显式 -1、0 和 1.

Objet

Si vous disposez d'un tableau d'objets, cela fonctionne de la même manière :

function cmp($a, $b) {
    return $a->baz - $b->baz;
}

Fonction

Vous pouvez faire tout ce dont vous avez besoin dans la fonction de comparaison, y compris appeler des fonctions :

function cmp(array $a, array $b) {
    return someFunction($a['baz']) - someFunction($b['baz']);
}

Chaîne

Raccourci pour la première version de comparaison de chaînes :

function cmp(array $a, array $b) {
    return strcmp($a['foo'], $b['foo']);
}

strcmp 完全符合 cmp 的预期，它返回 -1、0 或 1.

Opérateur de vaisseau spatial

PHP 7 introduit le opérateur de vaisseau spatial, qui unifie et simplifie les comparaisons égal/inférieur/supérieur à entre les types :

function cmp(array $a, array $b) {
    return $a['foo'] <=> $b['foo'];
}

Trier par plusieurs champs

Si vous souhaitez trier principalement par foo, mais si les foo de deux éléments sont égaux, alors triez par foo 排序，但如果两个元素的 foo 相等，则按 baz :

function cmp(array $a, array $b) {
    if (($cmp = strcmp($a['foo'], $b['foo'])) !== 0) {
        return $cmp;
    } else {
        return $a['baz'] - $b['baz'];
    }
}

Pour ceux qui sont familiers, cela équivaut à une requête SQL utilisant ORDER BY foo, baz.
Voir aussi cette version abrégée très conciseet comment créer dynamiquement une telle fonction de comparaison pour n'importe quel nombre de clés.

Trier par ordre statique manuel

Si vous souhaitez trier les éléments dans un "ordre manuel" comme "foo", "bar", "baz"  :

function cmp(array $a, array $b) {
    static $order = array('foo', 'bar', 'baz');
    return array_search($a['foo'], $order) - array_search($b['foo'], $order);
}

---

Pour tout ce qui précède, si vous utilisez PHP 5.3 ou supérieur (et vous devriez vraiment le faire), utilisez des fonctions anonymes pour raccourcir votre code et éviter une autre fonction globale :

usort($array, function (array $a, array $b) { return $a['baz'] - $b['baz']; });

C'est un moyen simple de trier des tableaux multidimensionnels complexes. Encore une fois, apprenez à PHP comment déterminer lequel des deux éléments est "le plus gros" laissez PHP faire le tri.

De plus, pour tout ce qui précède, pour basculer entre l'ordre croissant et décroissant, échangez simplement les paramètres $a 和 $b. Par exemple :

return $a['baz'] - $b['baz']; // ascending
return $b['baz'] - $a['baz']; // descending

Trier un tableau en fonction d'un autre tableau

Il y en a aussi un plus sophistiqué array_multisort qui vous permet de trier un tableau en fonction de : Un autre :

$array1 = array( 4,   6,   1);
$array2 = array('a', 'b', 'c');

Le résultat attendu ici est :

$array2 = array('c', 'a', 'b');  // the sorted order of $array1

Allez-y en utilisant array_multisort :

array_multisort($array1, $array2);

À partir de PHP 5.5.0, vous pouvez utiliser array_column pour extraire une colonne d'un tableau multidimensionnel et trier le tableau sur cette colonne :

array_multisort(array_column($array, 'foo'), SORT_DESC, $array);

Vous pouvez également trier plusieurs colonnes dans les deux sens :

array_multisort(array_column($array, 'foo'), SORT_DESC,
                array_column($array, 'bar'), SORT_ASC,
                $array);

À partir de PHP 7.0.0, vous pouvez également extraire les propriétés d'un tableau d'objets.

---