首页 > 博客列表 > 数组排序-合并-成员统计-交差并补

博主信息

博文 70

粉丝 1

访问量 68776

专题推荐

更多>

数组排序-合并-成员统计-交差并补

作业内容：数组的排序, 数组的合并, 数组成员的统计, 数组的交差并补等，任意选一个专题，至少10个函数，写出演示案例并提交到博客中。。。注意：课堂中讲过的函数在本地练习，不要提交到作业中了。。。。

课后练习的作博客文章已发布
- 常用数组函数-创建-删除-键值操作-回调函数
- 二维数组排序-搜索-增删改查-多维数组递归

1. 数组排序

/* 数组排序 */
$arr = ['b' => 'b', 'c' => 3, 'a' => 'a', 'e' => 5, 'd' => 4];
echo '$arr = ', print_r($arr, true), '<br>';
echo '<br>';

1.1 按键排序

/**
 * 按键排序
 */
echo '1. 按键排序<br>';
// 按键升序
$test = $arr;
ksort($test);
// ksort: Array ( [a] => a [b] => b [c] => 3 [d] => 4 [e] => 5 )
echo 'ksort: ', print_r($test, true), '<br>';
// 按键降序
$test = $arr;
krsort($test);
// krsort: Array ( [e] => 5 [d] => 4 [c] => 3 [b] => b [a] => a )
echo 'krsort: ', print_r($test, true), '<br>';
echo '<hr>';

按键排序

1.2 按值排序

/**
 * 按值排序
 */
echo '2. 按值排序<br>';
echo '按值升 | 降序，重排索引<br>';
// 按值升序，重排索引
$test = $arr;
sort($test);
// sort: Array ( [0] => a [1] => b [2] => 3 [3] => 4 [4] => 5 )
echo 'sort: ', print_r($test, true), '<br>';
// 按值降序，重排索引
$test = $arr;
rsort($test);
// rsort: Array ( [0] => 5 [1] => 4 [2] => 3 [3] => b [4] => a )
echo 'rsort: ', print_r($test, true), '<br>';
echo '<br>';
echo '按值升 | 降序，键名不变<br>';
$test = $arr;
// 按值升序，键名不变
asort($test);
// asort: Array ( [a] => a [b] => b [c] => 3 [d] => 4 [e] => 5 )
echo 'asort: ', print_r($test, true), '<br>';
$test = $arr;
// 按值降序，键名不变
arsort($test);
// arsort: Array ( [e] => 5 [d] => 4 [c] => 3 [b] => b [a] => a )
echo 'arsort: ', print_r($test, true), '<br>';
echo '<hr>';

按值排序

1.3 回调排序

/**
 * 回调排序
 */
echo '3. 回调排序<br>';
echo '回调函数按键名升 | 降序<br>';
$test = $arr;
// 回调函数按键名升序
uksort($test, function($a, $b){
    return $a <=> $b;
});
// uksort: Array ( [a] => a [b] => b [c] => 3 [d] => 4 [e] => 5 )
echo 'uksort: ', print_r($test, true), '<br>';
$test = $arr;
// 回调函数按键名降序
uksort($test, function($a, $b){
    return $b <=> $a;
});
// uksort: Array ( [e] => 5 [d] => 4 [c] => 3 [b] => b [a] => a )
echo 'uksort: ', print_r($test, true), '<br>';
echo '<br>';
echo '回调函数按值升 | 降序，重排索引<br>';
$test = $arr;
// 回调函数按值升序，重排索引
usort($test, function($a, $b){
    return $a <=> $b;
});
// usort: Array ( [0] => a [1] => b [2] => 3 [3] => 4 [4] => 5 )
echo 'usort: ', print_r($test, true), '<br>';
// 回调函数按值降序，重排索引
usort($test, function($a, $b){
    return $b <=> $a;
});
// usort: Array ( [0] => 5 [1] => 4 [2] => 3 [3] => b [4] => a )
echo 'usort: ', print_r($test, true), '<br>';
echo '<br>';
echo '回调函数按值升 | 降序，键名不变<br>';
$test = $arr;
// 回调函数按值升序，键名不变
uasort($test, function($a, $b){
    return $a <=> $b;
});
// uasort: Array ( [a] => a [b] => b [c] => 3 [d] => 4 [e] => 5 )
echo 'uasort: ', print_r($test, true), '<br>';
// 回调函数按值升序，键名不变
uasort($test, function($a, $b){
    return $b <=> $a;
});
// uasort: Array ( [e] => 5 [d] => 4 [c] => 3 [b] => b [a] => a )
echo 'uasort: ', print_r($test, true), '<br>';
echo '<hr>';

回调排序

1.4 自然排序

/**
 * 自然排序
 */
echo '4. 自然排序<br>';
$test = $arr;
// 自然排序，数字在前，字母在后
natsort($test);
// natsort: Array ( [c] => 3 [d] => 4 [e] => 5 [a] => a [b] => b )
echo 'natsort: ', print_r($test, true), '<br>';
$test = $arr;
// 自然排序，数字在前，字母在后
natcasesort($test);
// natcasesort: Array ( [c] => 3 [d] => 4 [e] => 5 [a] => a [b] => b )
echo 'natcasesort: ', print_r($test, true), '<br>';
echo '<hr>';

自然排序

1.5 多组排序

/**
 * 多组排序
 */
echo '5. 多组排序<br>';
$test = [
    ['id' => 2, 'name' => 'b-title'],
    ['id' => 1, 'name' => '1-title'],
    ['id' => 3, 'name' => 'c-title'],
];
echo '排序前二维数组: <pre>', print_r($test, true), '</pre><br>';
// 按 id 升序
array_multisort($test, array_column($test, 'id'));
echo 'array_multisort: id 升序(默认) <pre>', print_r($test, true), '</pre><br>';
// 按 id 降序
array_multisort($test, SORT_DESC, array_column($test, 'id'));
echo 'array_multisort: id 降序<pre>', print_r($test, true), '</pre><br>';
// 按 name 自然排序(数字在前,字母接后)
array_multisort($test, SORT_NATURAL, array_column($test, 'name'));
echo 'array_multisort: name 自然排序<pre>', print_r($test, true), '</pre><br>';

多组排序

多组升降序

多组自然排序

1.6 反转排序

/**
 * 反转排序
 */
echo '6. 反转排序<br>';
// 数组反转排序
$test = array_reverse($arr);
// array_reverse: Array ( [d] => 4 [e] => 5 [a] => a [c] => 3 [b] => b )
echo 'array_reverse: ', print_r($test, true), '<br>';
// 数组反转保留数字键名
$test = array_reverse($arr, true);
// array_reverse: Array ( [d] => 4 [e] => 5 [a] => a [c] => 3 [b] => b )
echo 'array_reverse: ', print_r($test, true), '<br>';
echo '<hr>';

反转排序

1.7 随机排序

/**
 * 随机排序
 */
echo '7. 随机排序<br>';
$test = $arr;
// 乱序排列，重排索引
shuffle($test);
// Array ( [0] => b [1] => 4 [2] => 5 [3] => a [4] => 3 )
echo 'shuffle: ', print_r($test, true), '<br>';
echo '<hr>';

随机排序

2. 数组合并

2.1 键值对合并

/* 数组合并 */
$arr1 = ['a' => 1, 'b' => 2, 3 => 'c'];
$arr2 = [1 => 'a', 'b' => 'b', 3 => 3];
echo '数组合并<br>';
echo '1. 键值对合并<br>';
// arr1 的值作键名,arr2 的值作值组成数组
$test = array_combine($arr1, $arr2);
// array_combine: Array ( [1] => a [2] => b [c] => 3 )
echo 'array_combine: <pre>', print_r($test, true), '</pre><br>';

键值对合并

2.2 数组合并

echo '2. 数组合并<br>';
// 数组合并
$test = array_merge($arr1, $arr2);
// 数字索引重排,相同字符串键名,后值覆盖前值
// array_merge: Array ( [a] => 1 [b] => b [0] => c [1] => a [2] => 3 )
echo 'array_merge: <pre>', print_r($test, true), '</pre><br>';

数组合并

2.3 递归合并

echo '3. 递归合并<br>';
// 数组递归合并,相同字符串键名,值合并
$test = array_merge_recursive($arr1, $arr2);
// array_merge_recursive: Array ( [a] => 1 [b] => Array ( [0] => 2 [1] => b ) [0] => c [1] => a [2] => 3 )
echo 'array_merge_recursive: <pre>', print_r($test, true), '</pre><br>';

递归合并

2.4 自定义函数合并

echo '4. 自定义函数合并<br>';
// 多维数组合并保留键名不变,相同键名或索引,后值覆盖前值
function array_merge_multi(...$args) {
    $array = [];
    foreach ( $args as $arg ) {
        if ( is_array($arg) ) {
            foreach ( $arg as $k => $v ) {
                if ( is_array($v) ) {
                    $array[$k] = isset( $array[$k] ) ? $array[$k] : [];
                    $array[$k] = array_merge_multi( $array[$k], $v );
                } else {
                    $array[$k] = $v;
                }
            }
        }
    }
    return $array;
}
$test = array_merge_multi($arr1, $arr2);
// array_merge_multi: Array ( [a] => 1 [b] => b [3] => 3 [1] => a )
echo 'array_merge_multi: <pre>', print_r($test, true), '</pre><br>';
echo '<hr>';

自定义函数合并

3. 数组成员统计

3.1 统计成员数目

/* 数组成员的统计 */
$test = $arr1 + $arr2;
echo '$test = ', print_r($test, true), '<br>';
echo '1. 统计成员数目<br>';
// 统计数组中项目个数
// count($test) : 4
echo 'count($test) : ', count($test), '<br>';

3.2 统计值出现的次数数组

echo '2. 统计值出现的次数数组<br>';
// 数组由值组成键名,值出现的次数为值
// array_count_values($test) : Array ( [1] => 1 [2] => 1 [c] => 1 [a] => 1 )
echo 'array_count_values($test) : <pre>', print_r(array_count_values($test), true), '</pre><br>';
echo '<hr>';

数组成员统计

4. 数组的交差并补

4.1 数组交集

/* 数组的交差并补 */
$arr1 = ['a' => 'b', 'b' => 'a', 1 => 'a', 2 => 'b'];
$arr2 = [1 => 'a', 'a' => 'b', 'b' => 1];
echo '数组的交差并补<br>';
echo "\$$arr1 = ['a' => 'b', 'b' => 'a', 1 => 'a', 2 => 'b'];<br>";
echo "\$$arr2 = [1 => 'a', 'a' => 'b', 'b' => 1];<br>";
echo '<br>';
echo '数组交集<br>';
echo '1. 数组交集值相等型<br>';
// 数组交集，只需值相等（主从数组键名不同时，保留主数组的键名）
// array_intersect : Array ( [a] => b [b] => a [1] => a [2] => b )
echo 'array_intersect : ', print_r(array_intersect($arr1, $arr2), true), '<br>';
echo '2. 数组交集键值严格相等型<br>';
// 数组交集，键值严格相等
// array_intersect_assoc : Array ( [a] => b [1] => a )
echo 'array_intersect_assoc : ', print_r(array_intersect_assoc($arr1, $arr2), true), '<br>';
echo '3. 数组交集键相等型<br>';
// 数组交集，键相等（主从数组值不同时，保留主数组的值）
// array_intersect_key : Array ( [a] => b [b] => a [1] => a )
echo 'array_intersect_key : ', print_r(array_intersect_key($arr1, $arr2), true), '<br>';
echo '<br>';

数组交集

4.2 数组差集

echo '数组差集<br>';
echo '1. 数组差集值相等型<br>';
// 数组差集，只需值相等（主从数组键名diff不同时，保留主数组的键名）
// array_diff : Array ( )
echo 'array_diff : ', print_r(array_diff($arr1, $arr2), true), '<br>';
echo '2. 数组差集键值严格相等型<br>';
// 数组差集，键值严格相等
// array_diff_assoc : Array ( [b] => a [2] => b )
echo 'array_diff_assoc : ', print_r(array_diff_assoc($arr1, $arr2), true), '<br>';
echo '3. 数组差集键相等型<br>';
// 数组差集，键相等（主从数组值不同时，保留主数组的值）
// array_diff_key : Array ( [2] => b )
echo 'array_diff_key : ', print_r(array_diff_key($arr1, $arr2), true), '<br>';
echo '<br>';

数组差集

4.3 数组并集

echo '数组并集<br>';
echo '1. 数组并集前值覆盖后值型<br>';
// $arr1 + $arr2 : Array ( [a] => b [b] => a [1] => a [2] => b )
echo '$arr1 + $arr2 : ', print_r($arr1 + $arr2, true), '<br>';
echo '<br>';
echo '2. 数组并集后值覆盖前值型<br>';
// 数字索引重排,相同字符串键名,后值覆盖前值
// array_merge : Array ( [a] => b [b] => 1 [0] => a [1] => b [2] => a )
echo 'array_merge : ', print_r(array_merge($arr1, $arr2), true), '<br>';
echo '<br>';
echo '3. 数组并集递归合并<br>';
// 数组递归合并,相同字符串键名,值合并
/* array_merge_recursive : 
    Array ( 
        [a] => Array ( [0] => b [1] => b ) 
        [b] => Array ( [0] => a [1] => 1 ) 
        [0] => a 
        [1] => b 
        [2] => a 
    )
*/
echo 'array_merge_recursive : <pre>', print_r(array_merge_recursive($arr1, $arr2), true), '</pre><br>';
echo '<br>';

数组并集

4.4 数组补集
…

批改老师：

天蓬老师

批改状态：合格

老师批语：

本博文版权归博主所有，转载请注明地址！如有侵权、违法，请联系admin@php.cn举报处理！

全部评论文明上网理性发言，请遵守新闻评论服务协议

0条评论

作者最新博文

值|引用传递-数组|对象解构-call|apply|bind-访问器-流程控制

2021-12-07 21:10:43