Cóż, większość podstawowych metod jest już objętych deceze spróbowałbym spojrzeć na inne rodzaje sort

Sortowanie za pomocą 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));

Wyjście

c
b
a

SplMaxHeap

Klasa SplMaxHeap zapewnia główne funkcje sterty, zachowując maksimum na górze.

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

SplMinHeap

Klasa SplMinHeap zapewnia główne funkcjonalności sterty, zachowując minimum na górze.

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

Inne rodzaje sortowania

Sortuj Bańki

Z artykułu Wikipedii na temat sortowania bąbelków:

Sortowanie Bąbelkowe, czasami niepoprawnie nazywane sortowaniem tonącym, jest prostym algorytmem sortowania, który działa poprzez wielokrotne przechodzenie przez Listę do sortowania, porównując każdą parę sąsiednich elementów i zamieniając je, jeśli są w złej kolejności. Przejście przez Listę jest powtarzane, dopóki nie są potrzebne żadne swapy, co oznacza, że lista jest posortowana. Algorytm dostaje swoją nazwę od sposobu, w jaki mniejsze elementy "bańki" na górę listy. Ponieważ używa tylko porównań do operowania na elementach, jest to rodzaj porównania. Chociaż algorytm jest prosty, większość innych algorytmów sortowania jest bardziej wydajna dla dużych list.

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

Sortowanie wyboru

Z artykuł w Wikipedii o sortowaniu selekcji:

W informatyce sortowanie selekcyjne jest algorytm sortowania, w szczególności sortowanie porównawcze w miejscu. Ma złożoność czasową O (n2), co sprawia, że jest nieefektywny na dużych listach i generalnie działa gorzej niż podobny rodzaj wstawiania. Sortowanie selekcji jest znane ze swojej prostoty i ma przewagę wydajności nad bardziej skomplikowanymi algorytmami w pewnych sytuacjach, szczególnie gdy pamięć pomocnicza jest ograniczona.

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

Sortowanie wstawiania

Z artykułu Wikipedii o wstawianiu Sortuj:

Sortowanie wstawiania jest prostym algorytmem sortowania, który buduje ostateczną sortowaną tablicę (lub listę) po jednym elemencie na raz. Jest znacznie mniej wydajny na dużych listach niż bardziej zaawansowane algorytmy, takie jak quicksort, heapsort lub sortowanie scalające. Jednak sortowanie wstawiania ma kilka zalet:

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

Z artykułu Wikipedii O Shellsort:

Shellsort, znany również jako Shell sort lub Shell ' s method, jest sortowanie w miejscu porównania. Uogólnia sortowanie wymiany, takie jak wstawianie lub sortowanie bąbelkowe, rozpoczynając porównanie i wymianę elementów z elementami, które są daleko od siebie, przed zakończeniem z sąsiadującymi elementami.

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

Sortowanie grzebieni

Z artykułu Wikipedii o grzebieniu:

Sortowanie grzebieniowe to stosunkowo prosty algorytm sortowania zaprojektowany przez Włodzimierza Dobosiewicza w 1980 roku. Później został na nowo odkryty przez Stephena Lacey i Richard Box w 1991 roku. Sortowanie grzebieniowe poprawia sortowanie bąbelkowe.

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

Sortowanie scalające

Z artykułu w Wikipedii o sortowaniu scalonym:

W informatyce, sortowanie scalające (również często pisane mergesort) jest algorytmem sortowania opartego na porównywaniu O(N log n). Większość implementacji tworzy stabilne sortowanie, co oznacza, że implementacja zachowuje porządek wejściowy równych elementów w sortowaniu Wyjście

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

Z artykułu Wikipedii O Quicksorcie:

Quicksort, czyli sortowanie partycji, to algorytm sortowania opracowany przez Tony 'ego Hoare' a, który średnio porównuje O(N log n) do sortowania N pozycji. W najgorszym przypadku dokonuje porównań O (n2), choć takie zachowanie jest rzadkie.

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

Sortowanie permutacji

Z artykułu Wikipedii o permutacji Sortuj:

Sortowanie permutacji, które następuje poprzez wygenerowanie możliwych permutacji tablicy/listy wejściowej, aż do odkrycia sortowanej.

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

Z artykułu Wikipedii O Radix sort:

W informatyce, Radix sort jest nieporównawczym algorytmem sortowania liczb całkowitych, który sortuje dane za pomocą kluczy całkowitych, grupując klucze według poszczególnych cyfr, które mają tę samą znaczącą pozycję i wartość.

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

Stabilne sortowanie

Powiedzmy, że masz tablicę taką jak ta:

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

A teraz chcesz sortować tylko na pierwszej literze:

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

Wynik jest taki:

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

Ten typ nie był stabilny!

Zapalony obserwator mógł zauważyć, że algorytm sortowania tablic (QuickSort) nie dał stabilnego wyniku i że pierwotny porządek między słowami tej samej pierwszej litery nie został zachowany. Ta sprawa jest banalna i powinniśmy porównać cały ciąg znaków, ale załóżmy, że Twój przypadek użycia jest bardziej skomplikowany, na przykład dwa kolejne rodzaje na różnych polach, które nie powinny anulować wzajemnie swojej pracy.

Transformata Schwartziana

Transformata Schwartziana , określana również jako idiom decorate-sort-undecorate, powoduje sortowanie stabilne za pomocą algorytmu sortowania niestabilnego z natury.

Najpierw dekorujesz każdy element tablicy inną tablicą zawierającą klucz główny (the wartość) i klucz drugorzędny (jego indeks lub pozycja):

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

To przekształca tablicę w to:

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

Teraz dostosowujemy krok porównania; porównujemy pierwszą literę ponownie, ale jeśli są takie same, klucz drugorzędny jest używany do zachowania oryginalnej kolejności:

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

Po czym udekorujemy:

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

Wynik końcowy:

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

A co z ponownym użyciem?

Trzeba było przepisać swoją funkcję porównawczą do pracy z przekształcone elementy tablicy; możesz nie chcieć edytować swoich delikatnych funkcji porównawczych, więc oto opakowanie dla funkcji porównawczej:

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

Napiszmy krok sortowania używając tej funkcji:

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

Począwszy od PHP 5.3 z zamknięciami możliwe jest również użycie zamknięcia do określenia kolejności sortowania.

Na przykład zakładając, że $array jest tablicą obiektów zawierających właściwość month.

 $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

W. NET, LINQ jest często używany do sortowania, co zapewnia o wiele ładniejszą składnię niż funkcje porównawcze, zwłaszcza gdy obiekty muszą być sortowane według wielu pól. Istnieje kilka portów LINQ do PHP, w tym yalinqo library*. Dzięki niemu tablice mogą być sortowane pojedynczą linią bez pisania złożonych funkcji porównawczych.

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

Porównania można dodatkowo dostosować, przekazując wywołanie zwrotne jako drugi argument, dla przykład:

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

Tutaj, '$v->count' jest skrótem function ($v) { return $v->count; } (można użyć dowolnego z nich). Te łańcuchy metod zwracają Iteratory, Iteratory mogą być przekształcone w tablice przez dodanie ->toArray() na końcu, jeśli zajdzie taka potrzeba.

Wewnętrznie, orderBy i pokrewne metody wywołują odpowiednie funkcje sortowania tablic(uasort, krsort, multisort, usort itd.).

LINQ zawiera wiele innych metod inspirowanych SQL: filtrowanie, grupowanie, łączenie, agregowanie itp. Najlepiej nadaje się do przypadków, gdy złożone przekształcenia na tablice i obiekty muszą być wykonywane bez polegania na bazach danych.

_{* opracowany przeze mnie, zobacz readme po więcej szczegółów i porównanie z innymi portami LINQ}

Wielowymiarowe Sortuj według wartości klucza

Naturalny rodzaj wielowymiarowej tablicy według wartości klucza, a także zachowuje oryginalną kolejność (nie Tasuj kluczy głównych):

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

Test case:

$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,
  ),
)
*/

Bardzo wygodne jest sortowanie tablic za pomocą posortowane Funkcja z Nspl :

Sortowanie podstawowe

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

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

Sortowanie według wyniku funkcji

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

Sortowanie tablicy wielowymiarowej

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

Sortowanie tablicy obiektów

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

Sortowanie z funkcją porównawczą

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

Możesz zobaczyć wszystkie te przykłady tutaj .

Istnieje kilka sposobów sortowania tablicy.Wspomnę o kilku metodach wykonania tego zadania.najpierw podam tablicę liczb całkowitych nazywaną '$ numbers'.

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

Jest to normalny sposób tworzenia tablicy. Załóżmy, że chcę posortować tę tablicę w porządku rosnącym.W tym celu można użyć metody ' sort ()'.

<?php

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

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

Rozważmy teraz wyjście tego,

Możesz zobaczyć sortowanie drukowanej tablicy liczb. Jeśli chcesz ten numer tablica sortowana jest w porządku malejącym, do tego zadania można użyć metody ' rsort ()'.

<?php

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

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

Rozważ wyjście..

Teraz tablica jest sortowana malejąco.Rozważmy tablicę asocjacyjną.Podam tablicę asocjacyjną (asocjacyjna tablica oznacza, że tablica, której każdy indeks ma unikalną wartość klucza.) like this,

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

Więc teraz chcę posortować tę tablicę w porządku rosnącym według ich wartości.metoda 'asort ()' może być użyta dla to.

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

Jeśli sortowanie w porządku malejącym według ich wartości, można użyć metody' arsort ()'. Załóżmy, że chcesz posortować tablicę według ich wartości klucza. W tym celu można użyć metody ' ksort ()'.

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

Teraz rozważ wyjście.

Teraz tablica jest sortowana według ich wartości klucza.Jeśli chcesz posortować tablicę w porządku malejącym według ich wartości klucza, możesz użyć metody ' krsort ()'.

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

Teraz tablica asocjacyjna jest posortowana w kolejność malejąca według ich wartości klucza.Spójrz na wyniki.

Są to niektóre metody sortowania tablicy w porządku rosnącym lub malejącym w php.Mam nadzieję, że wpadniesz na jakiś pomysł.Dziękuję!

Najprostszym jest użycie funkcji usort do sortowania tablicy bez pętli : Poniżej przykład:

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

To będzie sortować w kolejności desendingu:

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

To będzie sortować w odpowiedniej kolejności:

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