la plupart des méthodes de base sont déjà couvertes par deceze j'essaierais de regarder d'autres types de sorte

tri 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 les principales fonctionnalités d'un tas, garder le maximum en haut.

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

SplMinHeap

la classe SplMinHeap fournit les principales fonctionnalités d'un tas, en gardant le minimum sur le dessus.

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

autres sortes

Tri À Bulles

de l'article Wikipedia sur le tri des bulles:

le tri à bulles, parfois appelé à tort le tri coulant, est un algorithme de tri simple qui fonctionne en marchant à plusieurs reprises à travers la liste à trier, en comparant chaque paire d'articles adjacents et en les échangeant s'ils sont dans le mauvais ordre. Le passage à travers la liste est répété jusqu'à ce qu'aucun swap ne soit nécessaire, ce qui indique que la liste est triée. L'algorithme tire son nom de la façon dont les petits éléments "bulle" en haut de la liste. Car il utilise uniquement les comparaisons pour opérer sur des éléments, c'est une sorte de comparaison. Bien que l'algorithme est simple, la plupart des autres algorithmes de tri sont plus efficaces pour les grandes listes.

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

tri de sélection

de L'article de Wikipedia sur le tri de sélection:

en informatique, tri de sélection est un algorithme de tri, spécifiquement un tri de comparaison sur place. Il a une complexité de temps O(n2), ce qui le rend inefficace sur les grandes listes, et fonctionne généralement pire que le tri d'insertion similaire. Tri de sélection est noté pour sa simplicité, et il a des avantages de performance sur les algorithmes plus complexes dans certaines situations, en particulier lorsque la mémoire auxiliaire est limitée.

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

Insertion tri

de L'article Wikipedia sur le tri D'Insertion:

Tri D'Insertion est un algorithme de tri simple qui construit le tableau (ou la liste) final trié un élément à la fois. Il est beaucoup moins efficace sur les grandes listes que des algorithmes plus avancés tels que quicksort, heapsort, ou merge sort. Cependant, le tri par insertion présente plusieurs avantages:

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

Shellsort

de L'article Wikipedia sur Shellsort:

Shellsort, également connu sous le nom de Shell sort ou la méthode de Shell, est un tri de comparaison en place. Il généralise une sorte d'échange, telle que l'insertion ou le type de bulle, en commençant la comparaison et l'échange d'éléments avec des éléments qui sont très éloignés avant de finir avec des éléments voisins.

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

Peigne de tri

de L'article de Wikipedia sur le tri au peigne fin:

comb sort est un algorithme de tri relativement simple conçu à l'origine par Wlodzimierz Dobosiewicz en 1980. Plus tard, elle fut redécouverte par Stephen Lacey et Richard Box en 1991. Le tri au peigne améliore le tri à la bulle.

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

Fusion tri

de L'article de Wikipedia sur la fusion sort:

En informatique, une sorte de fusion (également mergesort) est un algorithme de tri basé sur la comparaison O(N log n). La plupart des implémentations produisent un sort stable, ce qui signifie que l'implémentation préserve l'ordre d'entrée des éléments égaux dans la sortie triée

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

Quicksort

de l'article de Wikipedia sur Quicksort:

Quicksort, ou partition-exchange sort, est un tri algorithme développé par Tony Hoare qui, en moyenne, fait des comparaisons O(N log n) pour trier n articles. Dans le pire des cas, il fait des comparaisons O(n2), bien que ce comportement soit rare.

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

Permutation de tri

de L'article de Wikipedia sur la Permutation sort:

permutation sort, qui procède en générant les permutations possibles de l'entrée tableau / liste jusqu'à la découverte du 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;
}

Radix sort

de L'article de Wikipedia sur Radix sort:

en informatique, radix sort est un algorithme Non-comparatif de tri d'entiers qui trie des données avec des clés entières en groupant des clés par les chiffres individuels qui partagent la même position significative et la même valeur.

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

tri Stable

disons que vous avez un tableau comme ceci:

['Kale', 'Kaleidoscope', 'Aardvark', 'Apple', 'Leicester', 'Lovely']

et maintenant vous voulez trier sur la première lettre seulement:

usort($array, function($a, $b) {
    return strcmp($a[0], $b[0]);
});

le résultat est le suivant:

['Apple', 'Aardvark', 'Kale', 'Kaleidoscope', 'Lovely', 'Leicester']

le genre n'était pas stable!

l'observateur de keen peut avoir remarqué que L'algorithme de tri des tableaux (QuickSort) n'a pas produit un résultat stable et que l'ordre initial entre les mots de la même première lettre n'a pas été préservé. Ce cas est trivial et nous aurions dû comparer la chaîne entière, mais supposons que votre cas d'utilisation est plus compliqué, comme deux sortes consécutives sur des champs différents qui ne devraient pas annuler le travail de l'autre.

La Schwartzian transformer

La Schwartzian transformer , également désigné comme le decorate-sort-undecorate idiom, les effets d'une sorte stable avec un algorithme de tri intrinsèquement instable.

d'abord, vous décorez chaque élément du tableau avec un autre tableau comprenant une clé primaire (la valeur) et une clé secondaire (son index ou sa position):

array_walk($array, function(&$element, $index) {
    $element = array($element, $index); // decorate
});

cela transforme le tableau en ceci:

[
    ['Kale', 0], ['Kaleidoscope', 1], 
    ['Aardvark', 2], ['Apple', 3], 
    ['Leicester', 4], ['Lovely', 5]
]

maintenant, nous ajustons l'étape de comparaison; nous comparons à nouveau la première lettre, mais si elles sont les mêmes, le la clé secondaire est utilisée pour conserver la commande originale:

usort($array, function($a, $b) {
    // $a[0] and $b[0] contain the primary sort key
    // $a[1] and $b[1] contain the secondary sort key
    $tmp = strcmp($a[0][0], $b[0][0]);

    if ($tmp != 0) {
        return $tmp; // use primary key comparison results
    }

    return $a[1] - $b[1]; // use secondary key
});

après, nous undecorate:

array_walk($array, function(&$element) {
    $element = $element[0];
});

le résultat final:

['Aardvark', 'Apple', 'Kale', 'Kaleidoscope', 'Leicester', 'Lovely']

Qu'en est-il de la réutilisation?

vous avez dû réécrire votre fonction de comparaison pour travailler avec les éléments de tableau transformés; vous ne voulez peut-être pas éditer vos délicates fonctions de comparaison, donc voici un wrapper pour la comparaison de la fonction:

function stablecmp($fn)
{
    return function($a, $b) use ($fn) {
        if (($tmp = call_user_func($fn, $a[0], $b[0])) != 0) {
            return $tmp;
        } else {
            return $a[1] - $b[1];
        }
    };
}

écrivons l'étape de tri en utilisant cette fonction:

usort($array, stablecmp(function($a, $b) {
    return strcmp($a[0], $b[0]);
}));

voilà! Ton code de comparaison est revenu.

de PHP 5.3 avec des fermetures, il est également possible d'utiliser une fermeture à déterminer l'ordre de tri.

par exemple en supposant $array est un tableau d'objets qui contiennent une propriété de mois.

 $orderArray = array("Jan","Feb","Mar","Apr","May","June","July","Aug","Sept","Oct","Nov","Dec");

 usort($array, function($a, $b) use ($orderArray){
       return array_search($a->month, $orderArray) - array_search($b->month, $orderArray);
 }); 

LINQ

dans .NET, LINQ est fréquemment utilisé pour le tri, ce qui fournit une syntaxe beaucoup plus agréable sur les fonctions de comparaison, en particulier lorsque les objets doivent être triés par plusieurs champs. Il y a plusieurs ports de LINQ vers PHP, dont YaLinqo library*. Avec elle, les tableaux peuvent être triés avec une seule ligne sans écrire des fonctions de comparaison complexes.

$sortedByName         = from($objects)->orderBy('$v->name');
$sortedByCount        = from($objects)->orderBy('$v->count');
$sortedByCountAndName = from($objects)->orderBy('$v->count')->thenBy('$v->name');

peuvent être personnalisées par passer un appel comme second argument, par exemple:

$sortedByFilenameNat  = from($objects)->orderBy('$v->filename', 'strnatcmp');

ici, '$v->count' est un raccourci pour function ($v) { return $v->count; } (l'un ou l'autre peut être utilisé). Ces chaînes de méthode renvoient des itérateurs, les itérateurs peuvent être transformés en tableaux en ajoutant ->toArray() à la fin si nécessaire.

interne, orderBy et les méthodes connexes appellent les fonctions appropriées de tri des réseaux ( uasort , krsort , multisort , usort etc.).

LINQ contient beaucoup plus de méthodes inspirées par SQL: filtrage, regroupement, assemblage, etc. Il est le mieux adapté pour les cas où les transformations complexes sur les tableaux et les objets doivent être effectuées sans compter sur les bases de données.

_{* développé par moi, voir readme pour plus de détails et comparaison avec d'autres ports LINQ}

tri multidimensionnel par valeur clé

sorte naturelle d'un ensemble multidimensionnel par une valeur clé et aussi garder l'ordre original (ne pas mélanger les clés principales):

function multisortByKeyValue( $k, $arr ) {
    $ids   = array();
    $index = 1;

    foreach ( $arr as $key => $row ) {
        $ids[ $key ] = intval( $row[ $k ] ) . '-' . $index . '-' . $key;
        $index ++;
    }

    natsort( $ids );

    $arr = array_merge( $ids, $arr );

    return $arr;
}

cas de Test:

$arr = array(
    'id1' => array(
        'label'    => 'ID 1',
        'priority' => 30,
    ),
    'id2' => array(
        'label'    => 'ID 2',
        'priority' => 70,
    ),
    'id3' => array(
        'label'    => 'ID 3',
        'priority' => 20,
    ),
    'id4' => array(
        'label'    => 'ID 4',
        'priority' => 30,
    ),
);

$sorted = multisortByKeyValue( 'priority', $arr );

// $sorted equals to:
/*
array (
  'id3' => array (
    'label' => 'ID 3',
    'priority' => 20,
  ),
  'id1' => array (
    'label' => 'ID 1',
    'priority' => 30,
  ),
  'id4' => array (
    'label' => 'ID 4',
    'priority' => 30,
  ),
  'id2' => array (
    'label' => 'ID 2',
    'priority' => 70,
  ),
)
*/

il est très commode de trier les tableaux avec trié fonction de Nspl :

triage de base

// Sort array
$sorted = sorted([3, 1, 2]);

// Sort array in descending order
$sortedDesc = sorted([3, 1, 2], true);

Tri par fonction résultat

// Sort array by the result of a given function (order words by length)
$sortedByLength = sorted(['bc', 'a', 'abc'], 'strlen');
$sortedByLengthDesc = sorted(['bc', 'a', 'abc'], true, 'strlen');

// Sort array by the result of user-defined function (order words by the 1st character)
$sortedByTheFirstCharacter = sorted(['bc', 'a', 'abc'], function($v) { return $v[0]; }); 

// Which is the same as
$sortedByTheFirstCharacter = sorted(['bc', 'a', 'abc'], itemGetter(0));
$sortedByTheFirstCharacterDesc = sorted(['bc', 'a', 'abc'], true, itemGetter(0));

// itemGetter(0) returns a function which takes an argument with access by index/key
// and returns the value at index 0

Triing multidimensional array

// Sort multidimensional array (sort list of users by their names)
$users = [
    array('name' => 'Robert', 'age' => 20),
    array('name' => 'Alex', 'age' => 30),
    array('name' => 'Jack', 'age' => 25),
];
$sortedByName = sorted($users, itemGetter('name'));
$sortedByNameDesc = sorted($users, true, itemGetter('name'));

// itemGetter('name') returns a function which takes an argument with access by index/key
// and returns the value of the 'name' key

tableau de tri d'objets

// Lets assume we have class User(name, age) with properties name and age
// and public methods getName() and getAge()
$users = [
    new User('Robert', 20),
    new User('Alex', 30),
    new User('Jack', 25),
];

// Sort list of objects by property value (sort list of users by their name)
$sortedByName = sorted($users, propertyGetter('name'));
$sortedByNameDesc = sorted($users, true, propertyGetter('name'));

// propertyGetter('name') returns a function which takes an object
// and returns the value of its 'name' property

// Sort list of objects by method result (sort list of users by their age)
$sortedByAge = sorted($users, methodCaller('getAge'));
$sortedByAgeDesc = sorted($users, true, methodCaller('getAge'));

// methodCaller('getAge') returns a function which takes an object
// and returns the result of its getAge() method

tri avec fonction de comparaison

// Sort with a comparison function (order words lexicographically with strcmp)
$sortedLexicographically = sorted(['bc', 'a', 'abc'], false, null, 'strcmp');

// Sort with user-defined comparison function (order words by the 1st character)
$sortedByTheFirstCharacter = sorted(['bc', 'a', 'abc'], false, null, function($v1, $v2) {
    return chr($v1[0]) - chr($v2[0]);
});

vous pouvez voir tous ces exemples ici .

Il y a plusieurs façons de trier un tableau.Je mentionnerai certaines méthodes pour accomplir cette tâche.tout d'abord , je vais donner un tableau d'entiers qui est appelé comme '$nombre'.

$number = array(8,9,3,4,0,1,2);

c'est la façon normale de créer un tableau. Supposons que , je veux trier ce tableau dans l'ordre croissant.Pour cela, " trier()' méthode peut être utilisée.

<?php

    $number = array(8,9,3,4,0,1,2);
    sort($number);

   foreach ($number as $value) {
       echo $value."  ";
   }
?>

maintenant considérer la production de cela,

vous pouvez voir le tableau des nombres imprimés est trié. Si vous voulez que le tableau de nombres soit en ordre décroissant, la méthode 'rsort()' peut être utilisée pour cette tâche.

<?php

     $number = array(8,9,3,4,0,1,2);
     rsort($number);

     foreach ($number as $value) {
        echo $value."  ";
     }
?>

envisager la sortie..

est maintenant trié par ordre décroissant.Ok, prenons l'exemple d'un tableau associatif.Je vais donner un cadre associatif tableau(tableau Associatif signifie que, d'Un tableau dont chaque indice a valeur de clé unique.) comme ceci,

$number = array('eight'=>8,'nine'=>9,'three'=>3,'fore'=>4,'zero'=>0,'one'=>1,'two'=>2);

donc, maintenant je veux trier ce tableau dans l'ordre croissant selon leur valeur.'asort () la méthode peut être utilisée pour cela.

<?php

   $number = array('eight'=>8,'nine'=>9,'three'=>3,'fore'=>4,'zero'=>0,'one'=>1,'two'=>2);
   asort($number);

   foreach ($number as $value) {
      echo $value."  ";
    }
?>

si on trie l'ordre décroissant selon leur valeur, On peut utiliser la méthode arsort (). Supposons que vous vouliez trier ce tableau en fonction de leur valeur clé. Dans ce cas, la méthode 'ksort()' peut être utilisée.

<?php

     $number = array('eight'=>8,'nine'=>9,'three'=>3,'fore'=>4,'zero'=>0,'one'=>1,'two'=>2);
     ksort($number);

     foreach ($number as $value) {
         echo $value."  ";
     }
?>

considère maintenant la sortie.

maintenant le tableau est trié selon leur valeur clé.Si vous voulez trier le tableau en ordre décroissant selon leur valeur clé, la méthode'krsort()' peut être utilisée.

<?php

    $number = array('eight'=>8,'nine'=>9,'three'=>3,'fore'=>4,'zero'=>0,'one'=>1,'two'=>2);
    krsort($number);

    foreach ($number as $value) {
       echo $value."  ";
    }
?>

maintenant tableau associatif est trié dans l'ordre décroissant selon leur valeur clé.Chercher à la sortie.

ce sont les quelques méthodes pour trier un tableau en ordre ascendant ou descendant en php.J'espère pour vous faire une idée.Je vous remercie!

le plus simple est d'utiliser la fonction usort pour trier le tableau sans aucune boucle : Voici un exemple:

   $array_compare= array("0" =>4,"1"=>2,"2"=>500,"3"=>100);

cela va trier dans l'ordre des désendeurs:

usort($array_compare, function($a, $b) {
        return ($b['x1'] - $a['x1']) > 0 ? 1 :-1;
    });

cela va trier dans l'ordre suivant :

usort($array_compare, function($a, $b) {
        return ($b['x1'] - $a['x1']) < 0 ? 1 :-1;
    });