有几种方法可以对数组进行排序。我将提到一些完成这项任务的方法。首先，我将给出一个整数数组，称为'$numbers'。

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

这是创建数组的正常方式。假设我想要对这个数组进行升序排序。为此，可以使用'sort()'方法。

<?php

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

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

现在考虑它的输出，

你可以看到打印的数字数组是排序的。如果你想要该数字数组排序是降序的，'rsort()'方法可以用于该任务。

<?php

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

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

考虑输出..

现在数组按降序排序。让我们考虑一个关联数组。我将给出一个关联数组(关联数组的意思是，每个索引都有唯一键值的数组)，就像这样，

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

那么，现在我想根据它们的值对这个数组进行升序排序。' sort()'方法可以用于此。

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

如果根据它们的值降序排序，则可以使用'arsort()'方法。 假设您想要根据键值对数组进行排序。在这种情况下，可以使用'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."  ";
     }
?>

现在考虑输出。

现在数组根据它们的键值排序。如果您想根据键值降序排序数组，可以使用'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."  ";
    }
?>

现在，关联数组按照键值降序排序。看看输出。

这些是php中按升序或降序排序数组的一些方法。我希望你能有所了解。谢谢你！

如果有人想要一个更简单的解决方案来操作数组，只需使用Laravel Collection包，它有一个实现的sortBy函数，可以让你简单地按键排序。

$collection->sortBy('forename')->sortBy('surname');

也就是说，为了先按a，然后按b，然后按c排序，正确的子句应该是

sortBy('c')->sortBy('b')->sortBy('a')

https://packagist.org/packages/tightenco/collect

基本一维数组

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

适用的排序函数:

排序 函数 带点 arsort 的作用 natcasesort ksort 作用

它们之间的区别仅仅在于是否保留键值关联(“a”函数)，是从低到高排序还是反向排序(“r”)，是对值排序还是对键排序(“k”)，以及如何比较值(“nat”vs. normal)。有关概述和进一步细节的链接，请参阅http://php.net/manual/en/array.sorting.php。

多维数组，包括对象数组

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

如果你想根据每个条目的'foo'键对$array排序，你需要一个自定义比较函数。上面的排序和相关函数工作在简单的值上，它们知道如何比较和排序。PHP并不简单地“知道”如何处理复杂的值，例如数组('foo' => 'bar'， 'baz' => 42);所以你需要讲出来。

为此，需要创建一个比较函数。该函数接受两个元素，如果认为这两个元素相等，则必须返回0，如果第一个值较低则返回一个小于0的值，如果第一个值较高则返回一个大于0的值。这就是所需要的:

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

通常，您会希望使用匿名函数作为回调。如果您想使用方法或静态方法，请参阅在PHP中指定回调的其他方法。

然后使用下列函数之一:

usort uasort uksort

同样，它们的区别只在于是否保持键-值关联并按值或键排序。详细信息请阅读他们的文档。

使用示例:

usort($array, 'cmp');

usort will take two items from the array and call your cmp function with them. So cmp() will be called with $a as array('foo' => 'bar', 'baz' => 42) and $b as another array('foo' => ..., 'baz' => ...). The function then returns to usort which of the values was larger or whether they were equal. usort repeats this process passing different values for $a and $b until the array is sorted. The cmp function will be called many times, at least as many times as there are values in $array, with different combinations of values for $a and $b every time.

要习惯这个想法，试试这个:

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

您所做的只是定义了一个自定义方法来比较两个项目，这就是您所需要的。这适用于各种价值观。

顺便说一下，这适用于任何值，这些值不一定是复杂的数组。如果你想要进行自定义比较，你也可以在简单的数字数组上进行比较。

Sort通过引用进行排序，不返回任何有用的东西!

请注意，数组排序到位，您不需要将返回值分配给任何东西。$array = sort($array)将数组替换为true，而不是一个排序的数组。只是数组($);的工作原理。

自定义数值比较

如果你想按baz键排序，它是数字，你所需要做的就是:

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

感谢MATH的力量，这将返回一个< 0,0或> 0的值，取决于$a是否小于、等于或大于$b。

注意，这对于浮点值并不适用，因为它们将被简化为int并失去精度。使用显式的-1、0和1返回值代替。

对象

如果你有一个对象数组，它的工作方式是一样的:

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

功能

你可以在比较函数中做任何你需要做的事情，包括调用函数:

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

字符串

第一个字符串比较版本的快捷方式:

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

STRCMP和CMP完全一样，它返回-1 0或1。

宇宙飞船操作符

PHP 7引入了宇宙飞船操作符，它统一并简化了不同类型之间的相等/较小/较大比较:

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

按多个字段排序

如果你想主要根据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'];
    }
}

对于那些熟悉的人来说，这相当于一个带有ORDER BY foo, baz的SQL查询。 还可以查看这个非常简洁的简写版本，以及如何为任意数量的键动态创建这样的比较函数。

按手动、静态顺序排序

如果你想将元素按“手动顺序”排序，比如“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);
}

---

对于上述所有问题，如果你使用的是PHP 5.3或更高版本(你真的应该这样做)，请使用匿名函数来缩短代码，并避免出现另一个全局函数:

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

这就是对一个复杂的多维数组进行排序的简单程度。同样，就像教PHP如何分辨两个项中哪一个“更大”一样;让PHP来做实际的排序。

同样，对于上述所有参数，要在升序和降序之间切换，只需交换$a和$b参数。例如:

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

根据一个数组对另一个数组排序

然后是特殊的array_multisort，它可以让你根据一个数组对另一个数组排序:

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

这里的预期结果是:

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

使用array_multisort来实现:

array_multisort($array1, $array2);

从PHP 5.5.0开始，你可以使用array_column从多维数组中提取一个列，并对该列上的数组进行排序:

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

你也可以对多个列进行排序:

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

从PHP 7.0.0开始，您还可以从对象数组中提取属性。

---

如果你有更多的常见情况，请随意编辑这个答案。

大多数基本的方法都已经讲过了，我会试着看看其他类型的排序

用SPL排序

碎片堆

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

输出

c
b
a

SplMaxHeap

SplMaxHeap类提供堆的主要功能，将最大值保持在顶部。

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

SplMinHeap

SplMinHeap类提供了堆的主要功能，将最小值保持在顶部。

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

其他类型的排序

冒泡排序

摘自维基百科关于冒泡排序的文章:

Bubble sort, sometimes incorrectly referred to as sinking sort, is a simple sorting algorithm that works by repeatedly stepping through the list to be sorted, comparing each pair of adjacent items and swapping them if they are in the wrong order. The pass through the list is repeated until no swaps are needed, which indicates that the list is sorted. The algorithm gets its name from the way smaller elements "bubble" to the top of the list. Because it only uses comparisons to operate on elements, it is a comparison sort. Although the algorithm is simple, most of the other sorting algorithms are more efficient for large lists.

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

选择排序

摘自维基百科关于选择排序的文章:

在计算机科学中，选择排序是一种排序算法，特别是就地比较排序。它有O(n2)的时间复杂度，使得它在大型列表上效率低下，并且通常比类似的插入排序执行得更差。选择排序以其简单性而闻名，并且在某些情况下，特别是在辅助内存有限的情况下，它比更复杂的算法具有性能优势。

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

插入排序

来自维基百科关于插入排序的文章:

插入排序是一种简单的排序算法，每次构建一个最终排序的数组(或列表)。在大型列表上，它的效率远远低于更高级的算法，如快速排序、堆排序或归并排序。然而，插入排序提供了几个优点:

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

来自维基百科关于Shellsort的文章:

Shellsort，也称为Shell排序或Shell的方法，是一种就地比较排序。它泛化了交换排序，例如插入排序或冒泡排序，方法是先与相距很远的元素比较和交换元素，然后再与相邻的元素完成比较和交换。

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

梳子排序

摘自维基百科关于梳状排序的文章:

梳状排序是由Wlodzimierz Dobosiewicz在1980年设计的一种相对简单的排序算法。后来，它在1991年被斯蒂芬·莱西和理查德·博克斯重新发现。梳状排序改进了冒泡排序。

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

去排序

摘自维基百科关于归并排序的文章:

在计算机科学中，归并排序(也通常拼写为mergesort)是一种O(n log n)基于比较的排序算法。大多数实现都会产生稳定的排序，这意味着实现会保留排序输出中相等元素的输入顺序

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

快速排序

维基百科上关于快速排序的文章:

快速排序，或分区交换排序，是由Tony Hoare开发的一种排序算法，平均而言，对n个项目进行O(n log n)次比较。在最坏的情况下，它进行O(n2)比较，尽管这种行为很少见。

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

排列排序

来自维基百科关于排列排序的文章:

排列排序，通过生成输入数组/列表的可能排列，直到发现已排序的数组/列表。

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排序的文章:

在计算机科学中，基数排序是一种非比较整数排序算法，它通过将键按具有相同重要位置和值的单个数字分组，对具有整数键的数据进行排序。

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

最简单的方法是使用usort函数对数组进行排序，而不需要任何循环: 下面是一个例子:

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

这将按降序排序:

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

这将按发送顺序排序:

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

使用Nspl中的sorted function对数组进行排序非常方便:

基本分类

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

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

按函数结果排序

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

多维数组排序

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

对象排序数组

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

用比较函数排序

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

你可以在这里看到所有这些例子。