Wie kann ich Arrays und Daten in PHP sortieren?

Nun, die meisten grundlegenden Methoden werden bereits von deceze abgedeckt. Ich würde versuchen, andere Arten von Sorten zu betrachten

Sortierung mit 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));

Ausgabe 

c
b
a

SplMaxHeap

Die SplMaxHeap-Klasse stellt die Hauptfunktionalitäten eines Heaps bereit, wobei das Maximum oben bleibt.

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

SplMinHeap

Die SplMinHeap-Klasse stellt die Hauptfunktionalitäten eines Heaps bereit, wobei das Minimum oben bleibt.

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

Andere Sortenarten

Bubble Sort

Aus dem Wikipedia-Artikel zu Bubble Sort:

Die Blasensortierung, die manchmal fälschlicherweise als sinkende Sortierung bezeichnet wird, ist ein einfacher Sortieralgorithmus, der wiederholt durch die zu sortierende Liste blättert, jedes Paar benachbarter Elemente miteinander vergleicht und diese austauscht, wenn sie in der falschen Reihenfolge liegen. Das Durchlaufen der Liste wird wiederholt, bis keine Auslagerungen erforderlich sind. Dies zeigt an, dass die Liste sortiert ist. Der Algorithmus erhält seinen Namen von der Art und Weise, wie kleinere Elemente "Blasen" an den Anfang der Liste setzen. Da nur Vergleiche zur Bearbeitung von Elementen verwendet werden, handelt es sich um eine Vergleichssortierung. Obwohl der Algorithmus einfach ist, sind die meisten anderen Sortieralgorithmen für große Listen effizienter.

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

Auswahl sortieren

Aus dem Wikipedia-Artikel zur Auswahl sortieren:

In der Informatik ist Auswahlsortierung ein Sortieralgorithmus, insbesondere eine Direktvergleichssortierung. Es hat O(n2) Zeitkomplexität, was es bei großen Listen ineffizient macht und im Allgemeinen schlechter abschneidet als die ähnliche Einfügesortierung. Die Auswahl der Auswahl ist für ihre Einfachheit bekannt und hat in bestimmten Situationen, insbesondere wenn der Hilfsspeicher begrenzt ist, Leistungsvorteile gegenüber komplizierteren Algorithmen.

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

Sortieren durch Einfügen

Aus dem Wikipedia-Artikel zum Einfügen sortieren:

Einfügungssortierung ist ein einfacher Sortieralgorithmus, der das endgültige sortierte Array (oder die Liste) jeweils einzeln erstellt. Es ist bei großen Listen viel weniger effizient als fortschrittlichere Algorithmen wie Quicksort, Heapsort oder Merge Sort. Die Sortierreihenfolge bietet jedoch mehrere Vorteile:

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

Aus dem Wikipedia-Artikel zu Shellsort:

Shellsort, auch Shell-Sortierung oder Shell-Methode genannt, ist eine Direktvergleichssortierung. Sie verallgemeinert eine Austauschsortierung, z. B. Einfügung oder Blasensortierung, indem der Vergleich und der Austausch von Elementen mit weit auseinander liegenden Elementen begonnen wird, bevor sie mit benachbarten Elementen beendet werden. 

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

Kamm sortieren

Von dem Wikipedia-Artikel über Kamm sortieren:

Kammsortierung ist ein relativ einfacher Sortieralgorithmus, der ursprünglich von Wlodzimierz Dobosiewicz im Jahr 1980 entwickelt wurde. Später wurde er von Stephen Lacey und Richard Box im Jahr 1991 wiederentdeckt. Kammsorte verbessert die Blasensortierung.

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

Zusammenführen, sortieren

Aus dem Wikipedia-Artikel zum Zusammenführen sortieren:

In der Informatik ist eine Zusammenführungssortierung (auch als häufig zusammengesetzter Zusammenführungsort bezeichnet) ein Vergleichsalgorithmus, der auf O (n log n) basiert. Die meisten Implementierungen erzeugen eine stabile Sortierung, dh die Implementierung behält die Eingabereihenfolge gleicher Elemente in der sortierten Ausgabe bei

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

Schnelle Sorte

Aus dem Wikipedia-Artikel zu Quicksort:

Quicksort oder Partitionsaustausch-Sortierung ist ein von Tony Hoare entwickelter Sortieralgorithmus, der im Durchschnitt O (n log n) Vergleiche anstellt, um n Elemente zu sortieren. Im schlimmsten Fall werden O(n2) Vergleiche durchgeführt, obwohl dieses Verhalten selten ist.

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

Permutationsart

Aus dem Wikipedia-Artikel zur Permutation sortieren:

Permutations-Sortierung, die durch Generieren der möglichen Permutationen des Eingabearrays/der Eingabeliste fortfährt, bis die sortierte gefunden wird.

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

Von dem Wikipedia-Artikel zu Radix sortieren:

In der Informatik ist Radix Sort ein nicht vergleichender ganzzahliger Sortieralgorithmus, der Daten mit ganzzahligen Schlüsseln sortiert, indem die Schlüssel nach den einzelnen Ziffern gruppiert werden, die dieselbe signifikante Position und denselben Wert haben. 

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

Stabile Sorte

Nehmen wir an, Sie haben ein Array wie dieses:

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

Und jetzt möchten Sie nur nach dem ersten Buchstaben sortieren:

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

Das Ergebnis ist folgendes:

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

Die Sortierung war nicht stabil!

Der aufmerksame Beobachter hat möglicherweise bemerkt, dass der Arraysortierungsalgorithmus (QuickSort) nicht zu einem stabilen Ergebnis geführt hat und dass die ursprüngliche Reihenfolge zwischen Wörtern desselben ersten Buchstabens nicht beibehalten wurde. Dieser Fall ist trivial, und wir hätten die gesamte Zeichenfolge vergleichen sollen. Nehmen wir jedoch an, Ihr Anwendungsfall ist komplizierter, z. B. zwei aufeinanderfolgende Sortierungen in verschiedenen Feldern, die die Arbeit des anderen nicht beeinträchtigen sollten.

Die schwartzianische Transformation

Die Schwartzian-Transformation , die auch als Dekorate-Sort-Undecorate-Sprache bezeichnet wird, bewirkt eine stabile Sortierung mit einem inhärent instabilen Sortieralgorithmus.

Zunächst dekorieren Sie jedes Array-Element mit einem anderen Array, das einen Primärschlüssel (den Wert) und einen Sekundärschlüssel (dessen Index oder Position) enthält:

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

Das verwandelt das Array in folgendes:

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

Nun passen wir den Vergleichsschritt an. Wir vergleichen den ersten Buchstaben noch einmal, aber wenn sie gleich sind, wird der Sekundärschlüssel verwendet, um die ursprüngliche Reihenfolge beizubehalten:

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

Danach verzieren wir:

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

Das Endergebnis:

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

Was ist mit der Wiederverwendung?

Sie mussten Ihre Vergleichsfunktion neu schreiben, um mit den transformierten Array-Elementen zu arbeiten. Möglicherweise möchten Sie Ihre empfindlichen Vergleichsfunktionen nicht bearbeiten. Hier ist ein Wrapper für die Vergleichsfunktion:

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

Schreiben wir den Sortierschritt mit dieser Funktion:

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

Voila! Ihr ursprünglicher Vergleichscode ist zurück.

Ab PHP 5.3 mit Schließungen ist es auch möglich, eine Schließung zu verwenden, um die Sortierreihenfolge zu bestimmen.

Angenommen, $ array ist ein Array von Objekten, die eine Monatseigenschaft enthalten.

 $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

In .NET wird häufig LINQ zum Sortieren verwendet, was eine wesentlich schönere Syntax für Vergleichsfunktionen bietet, insbesondere wenn Objekte nach mehreren Feldern sortiert werden müssen. Es gibt mehrere Ports von LINQ zu PHP, einschließlich YaLinqo library *. Damit können Arrays mit einer einzelnen Zeile sortiert werden, ohne komplexe Vergleichsfunktionen schreiben zu müssen.

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

Vergleiche können weiter angepasst werden, indem ein Rückruf als zweites Argument übergeben wird. Beispiel:

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

Hier ist '$v->count' eine Abkürzung für function ($v) { return $v->count; } (beide können verwendet werden). Diese Methodenketten geben Iteratoren zurück, Iteratoren können in Arrays umgewandelt werden, indem bei Bedarf am Ende ->toArray() hinzugefügt wird.

Intern rufen orderBy und verwandte Methoden geeignete Arraysortierungsfunktionen auf (uasort, krsort, multisort, usort usw.).

LINQ enthält viele weitere von SQL inspirierte Methoden: Filtern, Gruppieren, Verknüpfen, Aggregieren usw. Dies ist am besten für Fälle geeignet, in denen komplexe Transformationen von Arrays und Objekten ohne Datenbankabhängigkeit durchgeführt werden müssen.

_{* von mir entwickelt, siehe Readme für weitere Details und Vergleiche mit anderen LINQ-Ports}

Mehrdimensionale Sortierung nach Schlüsselwert

Natürliche Art eines mehrdimensionalen Arrays nach einem Schlüsselwert und auch die ursprüngliche Reihenfolge einhalten (die Hauptschlüssel nicht mischen):

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

Testfall:

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

Wenn Sie nach dem Schlüsselwert ordnen möchten, können Sie dies in einer Zeile, elegant und klar, tun. Dies wird nach aufsteigendem Preis sortiert. Verwendet array_multisort und array_column.

   Array([0] => Array ( [name] => eggs [price] => 1 ) [1] => Array ( [name] => coffee [price] => 9.99 ) [2] => Array ( [name] => rice [price] => 4.04 ) )

   array_multisort (array_column($array, 'price'), SORT_ASC, $array);

produzieren

     Array ( [0] => Array ( [name] => eggs [price] => 1 ) [1] => Array ( [name] => rice [price] => 4.04 ) [2] => Array ( [name] => coffee [price] => 9.99 ) )

Es ist sehr praktisch, Arrays mit sortiert - Funktion aus Nspl zu sortieren:

Basissortierung

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

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

Sortierung nach Funktionsergebnis

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

Mehrdimensionales Array sortieren

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

Sortierfeld von Objekten

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

Sortieren mit einer Vergleichsfunktion

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

Sie können alle diese Beispiele sehen hier .

Es gibt mehrere Möglichkeiten, ein Array zu sortieren. Ich erwähne einige Methoden, um diese task.fist auszuführen. Ich werde ein ganzzahliges Array angeben, das als '$ numbers' bezeichnet wird.

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

Dies ist der normale Weg zum Erstellen eines Arrays. Angenommen, ich möchte dieses Array in aufsteigender Reihenfolge sortieren. Dazu kann die 'sort ()' - Methode verwendet werden.

<?php

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

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

Betrachten Sie nun die Ausgabe davon,

Sie sehen, dass das gedruckte Zahlenfeld sortiert ist. Wenn Sie möchten, dass das Zahlenarray in absteigender Reihenfolge sortiert wird, kann die Methode 'rsort ()' für diese Aufgabe verwendet werden.

<?php

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

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

betrachte die Ausgabe ..

Das Array ist jetzt in absteigender Reihenfolge sortiert.Ok, betrachten wir ein assoziatives Array. Ich gebe ein assoziatives Array (Assoziatives Array bedeutet: Ein Array, dessen Index einen eindeutigen Schlüsselwert hat.)

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

Nun, ich möchte dieses Array in aufsteigender Reihenfolge nach ihrem Wert sortieren. Die Methode "asort ()" kann dafür verwendet werden.

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

Wenn Sie die absteigende Reihenfolge nach ihrem Wert sortieren, kann die 'arsort ()' - Methode verwendet werden . Angenommen, Sie möchten das Array nach ihrem Schlüsselwert sortieren. In diesem kann 'ksort ()' Methode verwendet werden.

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

Betrachten Sie nun die Ausgabe .  

Nun wird das Array nach ihrem Schlüsselwert sortiert. Wenn Sie das Array in absteigender Reihenfolge nach dem Schlüsselwert sortieren möchten, kann die Methode 'krsort ()' verwendet werden.

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

Nun wird das assoziative Array in absteigender Reihenfolge nach ihrem Schlüsselwert sortiert. Schauen Sie sich die Ausgabe an  

Dies sind einige Methoden, um ein Array in php auf- oder absteigend zu sortieren. Ich hoffe, Sie könnten eine Idee bekommen. Vielen Dank!