Sorting method of two-dimensional array in PHP

/**
* @package     BugFree
* @version     $Id: FunctionsMain.inc.php,v 1.32 2005/09/24 11:38:37 wwccss Exp $
*
*
* Sort an two-dimension array by some level two items use array_multisort() function.
*
* sysSortArray($Array,"Key1","SORT_ASC","SORT_RETULAR","Key2"……)
* @author                      Chunsheng Wang
* @param  array   $ArrayData   the array to sort.
* @param  string  $KeyName1    the first item to sort by.
* @param  string  $SortOrder1  the order to sort by("SORT_ASC"|"SORT_DESC")
* @param  string  $SortType1   the sort type("SORT_REGULAR"|"SORT_NUMERIC"|"SORT_STRING")
* @return array                sorted array.
*/
function sysSortArray($ArrayData,$KeyName1,$SortOrder1 = "SORT_ASC",$SortType1 = "SORT_REGULAR")
{
    if(!is_array($ArrayData))
    {
        return $ArrayData;
    }
 
    // Get args number.
    $ArgCount = func_num_args();
 
    // Get keys to sort by and put them to SortRule array.
    for($I = 1;$I < $ArgCount;$I ++)
    {
        $Arg = func_get_arg($I);
        if(!eregi("SORT",$Arg))
        {
            $KeyNameList[] = $Arg;
            $SortRule[]    = '$'.$Arg;
        }
        else
        {
            $SortRule[]    = $Arg;
        }
    }
 
    // Get the values according to the keys and put them to array.
    foreach($ArrayData AS $Key => $Info)
    {
        foreach($KeyNameList AS $KeyName)
        {
            ${$KeyName}[$Key] = $Info[$KeyName];
        }
    }
 
    // Create the eval string and eval it.
    $EvalString = 'array_multisort('.join(",",$SortRule).',$ArrayData);';
    eval ($EvalString);
    return $ArrayData;
}
 
 
//################# 示例 #################
$arr = array(
    array(
        'name'        =>    '学习',
        'size'        =>    '1235',
        'type'        =>    'jpe',
        'time'        =>    '1921-11-13',
        'class'        =>    'dd',
    ),
    array(
        'name'        =>    '中国功夫',
        'size'        =>    '153',
        'type'        =>    'jpe',
        'time'        =>    '2005-11-13',
        'class'        =>    'jj',
    ),
    array(
'name' => 'Programming',
'size' => '35',
'type' => 'gif',
'time' => '199 7-11-13',
'class ' 'dd',
),
array(
'name' => 'Chinese Kung Fu',
'size' => '65',
'type' => 'jpe',
' time'                                                                                                                                                        ‐‐‐‐‐‐‐‐‐‐‐‐‐‐ 'size' => ' 5 ',
' type '= & gt;' icon ',
' time '= & gt;' 1967-12-13 ',
' class' = & gt; 'rr',
); $arr);

//Note: 153 is smaller than 65 when sorted numerically
$temp = sysSortArray($arr,"name","SORT_ASC","type","SORT_DESC","size","SORT_ASC ","SORT_STRING");

print_r($temp);

?>



Other related sorting functions:

sort ( array &$array [, int $sort_flags] )

This function will sort the target array, and the elements will be arranged in order from low to high value. Note that the function parameters are passed by reference, and it does not return the sorted array. Instead, it just sorts the current array. , no value is returned regardless of the result.

Note: This function assigns new key names to the cells in array. This will delete the original key names instead of just reordering.

$arr = array(9,5 ,2,6,8,4,3,1); sort($arr); print_r($arr); ?>

Output: (You can see that the key-value association is no longer maintained)

Array ( [ 0] => 1 [1] => 2 [2] => 3 [3] => 4 [4] => 5 [5] => 6 [6] => 8 [7 ] => 9 )

asort ( array &$array [, int $sort_flags] )

This function sorts the array, and the index of the array remains associated with the unit. It is mainly used for those units where the order is important Combine the array for sorting. It is also passed by reference and does not return a value.

Output (you can see that the key values ​​remain unchanged):

Array ( [5] => 1 [1] => 2 [4] => 4 [0] => ; 5 [2] => 6 [3] => 8 )

rsort ( array &$array [, int $sort_flags] )

This function is similar to the sort function, sorting the array in reverse order (highest to lowest ).

Note: This function assigns new key names to the cells in array. This will delete the original keys rather than just reorder them.

Returns TRUE if successful and FALSE if failed.

arsort (array &$array [, int $sort_flags] )

This function sorts the array in reverse order, and the index of the array remains associated with the unit. Mainly used for sorting associative arrays where the order of cells is important. The arsort() function is the same as asort() except that it sorts the array elements in reverse order (descending order).

Returns TRUE if successful and FALSE if failed.

ksort ( array &$array [, int $sort_flags] )

The difference between ksort and sort is that the array is sorted by key name instead of by value, and the association between key name and data is retained. This function is mainly used for associative arrays . Returns TRUE if successful, FALSE if failed.

krsort (array &$array [, int $sort_flags] )
See ksort. This function is the same as ksort but sorts the results after ksort in reverse order.

natsort (array &$array)

This function implements a sorting algorithm in the same way that people usually sort alphanumeric strings and maintains the original key/value association. This is called "natural sorting" .The difference between this algorithm and the usual computer string sorting algorithm (used for sort()) is shown in the example below.

Returns TRUE if successful, and returns FALSE if failed.
There is a very classic example in the PHP manual

< ;?php $array1 = $array2 = array("img12.png", "img10.png", "img2.png", "img1.png"); sort($array1); echo "Standard sortingn"; print_r( $array1); natsort($array2); echo "nNatural order sortingn"; print_r($array2); ?>

The above example will output: Standard sorting

Array ( [0] => img1.png [ 1] => img10.png [2] => img12.png [3] => img2.png )

Natural order sorting

Array ( [3] => img1.png [2] = > img2.png [1] => img10.png [0] => img12.png )

There are also some array sorting functions starting with u(user), which are user-defined sorting functions. For time reasons, I won’t write more here.