Well most basic methods are already covered by deceze I would try to look at other types of sort

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

Output

c

b

a

SplMaxHeap

The SplMaxHeap class provides the main functionalities of a heap, keeping the maximum on the top.

$heap = new SplMaxHeap();

$heap->insert(1);

$heap->insert(2);

$heap->insert(3);

SplMinHeap

The SplMinHeap class provides the main functionalities of a heap, keeping the minimum on the top.

$heap = new SplMinHeap ();

$heap->insert(3);

$heap->insert(1);

$heap->insert(2);

Other Types of Sort

Bubble Sort

From the Wikipedia article on Bubble Sort:

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;

}

Selection sort

From the Wikipedia article on Selection sort:

In computer science, selection sort is a sorting algorithm, specifically an in-place comparison sort. It has O(n2) time complexity, making it inefficient on large lists, and generally performs worse than the similar insertion sort. Selection sort is noted for its simplicity, and it has performance advantages over more complicated algorithms in certain situations, particularly where auxiliary memory is limited.

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 sort

From the Wikipedia article on Insertion sort:

Insertion sort is a simple sorting algorithm that builds the final sorted array (or list) one item at a time. It is much less efficient on large lists than more advanced algorithms such as quicksort, heapsort, or merge sort. However, insertion sort provides several advantages:

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

From the Wikipedia article on Shellsort:

Shellsort, also known as Shell sort or Shell's method, is an in-place comparison sort. It generalizes an exchanging sort, such as insertion or bubble sort, by starting the comparison and exchange of elements with elements that are far apart before finishing with neighboring elements.

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;

}

Comb sort

From the Wikipedia article on Comb sort:

Comb sort is a relatively simple sorting algorithm originally designed by Wlodzimierz Dobosiewicz in 1980. Later it was rediscovered by Stephen Lacey and Richard Box in 1991. Comb sort improves on bubble sort.

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;

}

Merge sort

From the Wikipedia article on Merge sort:

In computer science, a merge sort (also commonly spelled mergesort) is an O(n log n) comparison-based sorting algorithm. Most implementations produce a stable sort, which means that the implementation preserves the input order of equal elements in the sorted output

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

From the Wikipedia article on Quicksort:

Quicksort, or partition-exchange sort, is a sorting algorithm developed by Tony Hoare that, on average, makes O(n log n) comparisons to sort n items. In the worst case, it makes O(n2) comparisons, though this behavior is 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 sort

From the Wikipedia article on Permutation sort:

Permutation sort, which proceeds by generating the possible permutations of the input array/list until discovering the sorted one.

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

From the Wikipedia article on Radix sort:

In computer science, radix sort is a non-comparative integer sorting algorithm that sorts data with integer keys by grouping keys by the individual digits which share the same significant position and value.

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

}

Stable sort

Let's say you have an array like this:

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

And now you want to sort on the first letter only:

usort($array, function($a, $b) {

    return strcmp($a[0], $b[0]);

});

The outcome is this:

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

The sort wasn't stable!

The keen observer may have noticed that the array sorting algorithm (QuickSort) didn't produce a stable outcome and that the original order between words of the same first letter wasn't preserved. This case is trivial and we should have compared the whole string, but let's assume your use-case is more complicated, such as two consecutive sorts on different fields that shouldn't cancel out each other's work.

The Schwartzian transform

The Schwartzian transform, also referred to as the decorate-sort-undecorate idiom, effects a stable sort with an inherently unstable sorting algorithm.

First, you decorate each array element with another array comprising a primary key (the value) and a secondary key (its index or position):

array_walk($array, function(&$element, $index) {

    $element = array($element, $index); // decorate

});

This transforms the array into this:

[

    ['Kale', 0], ['Kaleidoscope', 1], 

    ['Aardvark', 2], ['Apple', 3], 

    ['Leicester', 4], ['Lovely', 5]

]

Now, we adjust the comparison step; we compare the first letter again, but if they're the same, the secondary key is used to retain the original ordering:

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

});

Afterwards, we undecorate:

array_walk($array, function(&$element) {

    $element = $element[0];

});

The final result:

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

What about reuse?

You had to rewrite your comparison function to work with the transformed array elements; you may not want to edit your delicate comparison functions, so here's a wrapper for the comparison function:

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

        }

    };

}

Let's write the sort step using this function:

usort($array, stablecmp(function($a, $b) {

    return strcmp($a[0], $b[0]);

}));

Voila! Your pristine comparison code is back.

As of PHP 5.3 with closures it is also possible to use a closure to determine the order of your sort.

For example assuming $array is an array of objects that contain a month property.

 $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, LINQ is frequently used for sorting, which provides a much nicer syntax over comparison functions, especially when objects need to be sorted by multiple fields. There're several ports of LINQ to PHP, including YaLinqo library*. With it, arrays can be sorted with a single line without writing complex comparison functions.

$sortedByName         = from($objects)->orderBy('$v->name');

$sortedByCount        = from($objects)->orderBy('$v->count');

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

Comparisons can be further customized by passing a callback as a second argument, for example:

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

Here, '$v->count' is a shorthand for function ($v) { return $v->count; } (either can be used). These method chains return iterators, iterators can be transformed to arrays by adding ->toArray() in the end if needed.

Internally, orderBy and related methods call appropriate array sorting functions (uasort, krsort, multisort, usort etc.).

LINQ contains many more methods inspired by SQL: filtering, grouping, joining, aggregating etc. It's best suited for cases when complex transformations on arrays and objects need to be performed without relying on databases.

_{* developed by me, see readme for more details and comparison with other LINQ ports}

Multidimensional sort by key value

Natural sort of a multidimensional array by a key value and also keep the original order(do not shuffle the main keys):

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,

  ),

)

*/

It is very convenient to sort arrays with sorted function from Nspl:

Basic sorting

// Sort array

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



// Sort array in descending order

$sortedDesc = sorted([3, 1, 2], true);

Sorting by function result

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

Sorting 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

Sorting array of objects

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

Sorting with a comparison function

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

});

You can see all these examples here.

There are several ways to sort an array.I will mention some methods for doing that task.fist of all , I will give an integer array which is called as '$numbers'.

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

This is the normal way to creating an array. Suppose that , I want to sort that array in ascending order.For that, 'sort()' method can be used.

<?php



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

    sort($number);



   foreach ($number as $value) {

       echo $value."  ";

   }

?>

Now consider the output of that,

You can see printed number array is sorted. If you want to that number array to be sort is descending order, 'rsort()' method can be use for that task.

<?php



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

     rsort($number);



     foreach ($number as $value) {

        echo $value."  ";

     }

?>

consider the output..

Now array is sorted in descending order.Ok, Let's consider an associative array.I will give an associative array(Associative array means that, An array whose each index has unique key value.) like this,

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

So ,Now I want to sort this array in ascending order according their value.'asort()' method can be used for that.

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

    }

?>

If sorting descending order according their value,'arsort()' method can be used.
Suppose that you want to sort that array according their key value. In this , 'ksort()' method can be use.

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

     }

?>

Now consider the output.

Now array is sorted according their key value.If You want to sort the array in descending order according their key value,'krsort()' method can be used.

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

    }

?>

Now associative array is sorted in descending order according their key value.Look at the output.

These are the some methods for sorting an array in ascending or descending order in php.I hope to you could get an idea.Thank you!

The simplest is to use usort function to sort array without any looping :
Below is an example :

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

This will sort in desending order :

usort($array_compare, function($a, $b) {

        return ($b['x1'] - $a['x1']) > 0 ? 1 :-1;

    });

This will sort in asending order :

usort($array_compare, function($a, $b) {

        return ($b['x1'] - $a['x1']) < 0 ? 1 :-1;

    });