Community Learn Tools Library Leisure
search
English
Home > List of blog posts > 数组排序-合并-成员统计-交差并补
Blogger Information
Blog 70
fans 1
comment 0
visits 53092
Special Recommendation
More>
Related recommendations
Popular Tutorials
More>
Related Tutorials
Popular Recommendations
Latest courses
Latest Downloads
More>
Web Effects
Website Source Code
Website Materials
Front End Template
数组排序-合并-成员统计-交差并补
葡萄枝子
Original
745 people have browsed it

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

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

1. 数组排序

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

1.1 按键排序

  1. /**
  2.  * 按键排序
  3.  */
  4. echo '1. 按键排序<br>';
  5. // 按键升序
  6. $test = $arr;
  7. ksort($test);
  8. // ksort: Array ( [a] => a [b] => b [c] => 3 [d] => 4 [e] => 5 )
  9. echo 'ksort: ', print_r($test, true), '<br>';
  11. // 按键降序
  12. $test = $arr;
  13. krsort($test);
  14. // krsort: Array ( [e] => 5 [d] => 4 [c] => 3 [b] => b [a] => a )
  15. echo 'krsort: ', print_r($test, true), '<br>';
  16. echo '<hr>';

按键排序

1.2 按值排序

  1. /**
  2.  * 按值排序
  3.  */
  4. echo '2. 按值排序<br>';
  5. echo '按值升 | 降序，重排索引<br>';
  6. // 按值升序，重排索引
  7. $test = $arr;
  8. sort($test);
  9. // sort: Array ( [0] => a [1] => b [2] => 3 [3] => 4 [4] => 5 )
  10. echo 'sort: ', print_r($test, true), '<br>';
  12. // 按值降序，重排索引
  13. $test = $arr;
  14. rsort($test);
  15. // rsort: Array ( [0] => 5 [1] => 4 [2] => 3 [3] => b [4] => a )
  16. echo 'rsort: ', print_r($test, true), '<br>';
  17. echo '<br>';
  19. echo '按值升 | 降序，键名不变<br>';
  20. $test = $arr;
  21. // 按值升序，键名不变
  22. asort($test);
  23. // asort: Array ( [a] => a [b] => b [c] => 3 [d] => 4 [e] => 5 )
  24. echo 'asort: ', print_r($test, true), '<br>';
  26. $test = $arr;
  27. // 按值降序，键名不变
  28. arsort($test);
  29. // arsort: Array ( [e] => 5 [d] => 4 [c] => 3 [b] => b [a] => a )
  30. echo 'arsort: ', print_r($test, true), '<br>';
  31. echo '<hr>';

按值排序

1.3 回调排序

  1. /**
  2.  * 回调排序
  3.  */
  4. echo '3. 回调排序<br>';
  5. echo '回调函数按键名升 | 降序<br>';
  6. $test = $arr;
  7. // 回调函数按键名升序
  8. uksort($test, function($a, $b){
  9.     return $a <=> $b;
  10. });
  11. // uksort: Array ( [a] => a [b] => b [c] => 3 [d] => 4 [e] => 5 )
  12. echo 'uksort: ', print_r($test, true), '<br>';
  14. $test = $arr;
  15. // 回调函数按键名降序
  16. uksort($test, function($a, $b){
  17.     return $b <=> $a;
  18. });
  19. // uksort: Array ( [e] => 5 [d] => 4 [c] => 3 [b] => b [a] => a )
  20. echo 'uksort: ', print_r($test, true), '<br>';
  21. echo '<br>';
  23. echo '回调函数按值升 | 降序，重排索引<br>';
  24. $test = $arr;
  25. // 回调函数按值升序，重排索引
  26. usort($test, function($a, $b){
  27.     return $a <=> $b;
  28. });
  29. // usort: Array ( [0] => a [1] => b [2] => 3 [3] => 4 [4] => 5 )
  30. echo 'usort: ', print_r($test, true), '<br>';
  32. // 回调函数按值降序，重排索引
  33. usort($test, function($a, $b){
  34.     return $b <=> $a;
  35. });
  36. // usort: Array ( [0] => 5 [1] => 4 [2] => 3 [3] => b [4] => a )
  37. echo 'usort: ', print_r($test, true), '<br>';
  38. echo '<br>';
  40. echo '回调函数按值升 | 降序，键名不变<br>';
  41. $test = $arr;
  42. // 回调函数按值升序，键名不变
  43. uasort($test, function($a, $b){
  44.     return $a <=> $b;
  45. });
  46. // uasort: Array ( [a] => a [b] => b [c] => 3 [d] => 4 [e] => 5 )
  47. echo 'uasort: ', print_r($test, true), '<br>';
  49. // 回调函数按值升序，键名不变
  50. uasort($test, function($a, $b){
  51.     return $b <=> $a;
  52. });
  53. // uasort: Array ( [e] => 5 [d] => 4 [c] => 3 [b] => b [a] => a )
  54. echo 'uasort: ', print_r($test, true), '<br>';
  55. echo '<hr>';

回调排序

1.4 自然排序

  1. /**
  2.  * 自然排序
  3.  */
  4. echo '4. 自然排序<br>';
  5. $test = $arr;
  6. // 自然排序，数字在前，字母在后
  7. natsort($test);
  8. // natsort: Array ( [c] => 3 [d] => 4 [e] => 5 [a] => a [b] => b )
  9. echo 'natsort: ', print_r($test, true), '<br>';
  11. $test = $arr;
  12. // 自然排序，数字在前，字母在后
  13. natcasesort($test);
  14. // natcasesort: Array ( [c] => 3 [d] => 4 [e] => 5 [a] => a [b] => b )
  15. echo 'natcasesort: ', print_r($test, true), '<br>';
  16. echo '<hr>';

自然排序

1.5 多组排序

  1. /**
  2.  * 多组排序
  3.  */
  4. echo '5. 多组排序<br>';
  5. $test = [
  6.     ['id' => 2, 'name' => 'b-title'],
  7.     ['id' => 1, 'name' => '1-title'],
  8.     ['id' => 3, 'name' => 'c-title'],
  9. ];
  10. echo '排序前二维数组: <pre>', print_r($test, true), '</pre><br>';
  12. // 按 id 升序
  13. array_multisort($test, array_column($test, 'id'));
  14. echo 'array_multisort: id 升序(默认) <pre>', print_r($test, true), '</pre><br>';
  16. // 按 id 降序
  17. array_multisort($test, SORT_DESC, array_column($test, 'id'));
  18. echo 'array_multisort: id 降序<pre>', print_r($test, true), '</pre><br>';
  20. // 按 name 自然排序(数字在前,字母接后)
  21. array_multisort($test, SORT_NATURAL, array_column($test, 'name'));
  22. echo 'array_multisort: name 自然排序<pre>', print_r($test, true), '</pre><br>';

多组排序

多组升降序

多组自然排序

1.6 反转排序

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

反转排序

1.7 随机排序

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

随机排序

2. 数组合并

2.1 键值对合并

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

键值对合并

2.2 数组合并

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

数组合并

2.3 递归合并

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

递归合并

2.4 自定义函数合并

  1. echo '4. 自定义函数合并<br>';
  2. // 多维数组合并保留键名不变,相同键名或索引,后值覆盖前值
  3. function array_merge_multi(...$args) {
  4.     $array = [];
  5.     foreach ( $args as $arg ) {
  6.         if ( is_array($arg) ) {
  7.             foreach ( $arg as $k => $v ) {
  8.                 if ( is_array($v) ) {
  9.                     $array[$k] = isset( $array[$k] ) ? $array[$k] : [];
  10.                     $array[$k] = array_merge_multi( $array[$k], $v );
  11.                 } else {
  12.                     $array[$k] = $v;
  13.                 }
  14.             }
  15.         }
  16.     }
  17.     return $array;
  18. }
  19. $test = array_merge_multi($arr1, $arr2);
  20. // array_merge_multi: Array ( [a] => 1 [b] => b [3] => 3 [1] => a )
  21. echo 'array_merge_multi: <pre>', print_r($test, true), '</pre><br>';
  22. echo '<hr>';

自定义函数合并

3. 数组成员统计

3.1 统计成员数目

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

3.2 统计值出现的次数数组

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

数组成员统计

4. 数组的交差并补

4.1 数组交集

  1. /* 数组的交差并补 */
  2. $arr1 = ['a' => 'b', 'b' => 'a', 1 => 'a', 2 => 'b'];
  3. $arr2 = [1 => 'a', 'a' => 'b', 'b' => 1];
  5. echo '数组的交差并补<br>';
  6. echo "\$$arr1 = ['a' => 'b', 'b' => 'a', 1 => 'a', 2 => 'b'];<br>";
  7. echo "\$$arr2 = [1 => 'a', 'a' => 'b', 'b' => 1];<br>";
  8. echo '<br>';
  10. echo '数组交集<br>';
  11. echo '1. 数组交集值相等型<br>';
  12. // 数组交集，只需值相等（主从数组键名不同时，保留主数组的键名）
  13. // array_intersect : Array ( [a] => b [b] => a [1] => a [2] => b )
  14. echo 'array_intersect : ', print_r(array_intersect($arr1, $arr2), true), '<br>';
  16. echo '2. 数组交集键值严格相等型<br>';
  17. // 数组交集，键值严格相等
  18. // array_intersect_assoc : Array ( [a] => b [1] => a )
  19. echo 'array_intersect_assoc : ', print_r(array_intersect_assoc($arr1, $arr2), true), '<br>';
  21. echo '3. 数组交集键相等型<br>';
  22. // 数组交集，键相等（主从数组值不同时，保留主数组的值）
  23. // array_intersect_key : Array ( [a] => b [b] => a [1] => a )
  24. echo 'array_intersect_key : ', print_r(array_intersect_key($arr1, $arr2), true), '<br>';
  25. echo '<br>';

数组交集

4.2 数组差集

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

数组差集

4.3 数组并集

  1. echo '数组并集<br>';
  2. echo '1. 数组并集前值覆盖后值型<br>';
  3. // $arr1 + $arr2 : Array ( [a] => b [b] => a [1] => a [2] => b )
  4. echo '$arr1 + $arr2 : ', print_r($arr1 + $arr2, true), '<br>';
  5. echo '<br>';
  7. echo '2. 数组并集后值覆盖前值型<br>';
  8. // 数字索引重排,相同字符串键名,后值覆盖前值
  9. // array_merge : Array ( [a] => b [b] => 1 [0] => a [1] => b [2] => a )
  10. echo 'array_merge : ', print_r(array_merge($arr1, $arr2), true), '<br>';
  11. echo '<br>';
  13. echo '3. 数组并集递归合并<br>';
  14. // 数组递归合并,相同字符串键名,值合并
  15. /* array_merge_recursive : 
  16.     Array ( 
  17.         [a] => Array ( [0] => b [1] => b ) 
  18.         [b] => Array ( [0] => a [1] => 1 ) 
  19.         [0] => a 
  20.         [1] => b 
  21.         [2] => a 
  22.     )
  23. */
  24. echo 'array_merge_recursive : <pre>', print_r(array_merge_recursive($arr1, $arr2), true), '</pre><br>';
  25. echo '<br>';

数组并集

4.4 数组补集
…

Correcting teacher：天蓬老师天蓬老师

Correction status：qualified

Teacher's comments：
Statement of this Website
The copyright of this blog article belongs to the blogger. Please specify the address when reprinting! If there is any infringement or violation of the law, please contact admin@php.cn Report processing!
All comments Speak rationally on civilized internet, please comply with News Comment Service Agreement
0 comments
Author's latest blog post