PHP实现无限极分类的两种方式，递归和引用

说到无限极分类，比较常见的做法是在建表的时候，增加一个PID字段用来区别自己所属的分类 

由于展示数据的时候，需要表达出这种所属关系，所以必然要在读取数据的时候进行一系列处理，由此就牵涉到了两种算法

国民级算法——递归

从数据库取得二维数组省略，递归的思路其实很简单，遍历数组，根据每条数据的id值去寻找所有pid值等于自己id值的数据，直到找不到为止，实际实现起来也是通俗易懂

function getTree($arr,$pid=0,$level=0)
{
    static $list = [];
    foreach ($arr as $key => $value) {
        if ($value["auth_pid"] == $pid) {
            $value["level"] = $level;
            $list[] = $value;
            unset($arr[$key]); //删除已经排好的数据为了减少遍历的次数，当然递归本身就很费神就是了
            getTree($arr,$value["id"],$level+1);
        }
    }
    return $list;

基本也没啥好说的，这里返回去的是一个已经排序好的一维数组，展示的时候直接遍历就好，加入level字段是为了展示的时候，如果需要缩进，可以有个依据

巧妙的引用算法

上面的递归原理通俗易懂，但是总所周知的原因，递归对资源的消耗是非常大的，实际执行起来效率也很低，所以有了下面的通过引用算法

function generateTree($data){
    $items = array();
    foreach($data as $v){
        $items[$v['auth_id']] = $v;
    }
    $tree = array();
    foreach($items as $k => $item){
        if(isset($items[$item['auth_pid']])){
            $items[$item['auth_pid']]['son'][] = &$items[$k];
        }else{
            $tree[] = &$items[$k];
        }
    }
    return $tree;
}

是不是感觉有点谜之晕，慢慢分析这一段代码 
整个方法大体分成两个部分 
第一部分是

$items = array();
    foreach($data as $v){
        $items[$v['auth_id']] = $v;
    }

这一段应该是很通俗的，就是构建一个新的数组，新数组的key值是自己的主键id值 
进行完这一步之后，应该得到的数组形式是这样额

Array
(
    [100] => Array
        (
            [auth_id] => 100
            [auth_name] => 后台首页
            [auth_pid] => 0
        )
 
    [116] => Array
        (
            [auth_id] => 116
            [auth_name] => 管理员
            [auth_pid] => 0
        )
 
    [120] => Array
        (
            [auth_id] => 120
            [auth_name] => 管理员列表
            [auth_pid] => 116
        )
 
    [121] => Array
        (
            [auth_id] => 121
            [auth_name] => 管理员添加
            [auth_pid] => 116
        )
 
    [122] => Array
        (
            [auth_id] => 122
            [auth_name] => 数据一览
            [auth_pid] => 100
        )
 
    [123] => Array
        (
            [auth_id] => 123
            [auth_name] => 更新日志
            [auth_pid] => 100
        )
)

至于为什么要特地多一次遍历来将数组的KEY值重构，这里就是第二部分的巧妙之处了

$tree = array();
    foreach($items as $k => $item){
        if(isset($items[$item['auth_pid']])){
            $items[$item['auth_pid']]['son'][] = &$items[$k];
        }else{
            $tree[] = &$items[$k];
        }
    }
    return $tree;

慢慢的分析一下，这段代码将已经重构的数组遍历 
并判断当前数组元素的父级分类是否存在 
举个例子 foreach第一次循环的时候

$k = 100;
$item = Array
        (
            [auth_id] => 100
            [auth_name] => 后台首页
            [auth_pid] => 0
        )
 $items[$item['auth_pid']] = $items[0]; //不存在键值为0的数组元素，证明是顶级分类
 isset($items[$item['auth_pid']]) = false;
 $tree[] = &$items[$k];

注意到这里，是采取引用的方式，为什么呢？因为后面，其实我们的数组元素是会变化的 
当foreach第三次循环的时候，同样分析

$k = 120;
$item = Array
        (
            [auth_id] => 120
            [auth_name] => 管理员列表
            [auth_pid] => 116
        )
 $items[$item['auth_pid']] = $items[116];
 isset($items[$item['auth_pid']]) = true; //存在键值为116的数组元素，证明这个元素是键值116元素的子分类
 $items[$item['auth_pid']]['son'][] = &$items[$k];//给键值为116的数组元素增加一个son键，并将当前遍历的这个元素赋值给这个键

这里也是采取了引用，还是那个原因，因为当前遍历的元素很有可能还有子分类，当有子分类的时候，按照这个算法，他自己还要增加son这个键，所以采用引用赋值的方式，可以保证自己的结构是完美的

整体来看这个算法，如果加上两句输出来看一下

$tree = array();
    foreach($items as $k => $item){
        if(isset($items[$item['auth_pid']])){
            $items[$item['auth_pid']]['son'][] = &$items[$k];
            echo "1111<br>";
        }else{
            echo "2222<br>";
            $tree[] = &$items[$k];
        }
    }

那么会得到这样的结果

2222
2222
1111
1111
1111
1111

可以看到，其实$tree里面只有两个数组元素，而这两个数组元素是带有son键的，在son键里面保存着自己的所有后代元素 
进行完这个算法之后，得到的结果会是这样的

Array
(
    [0] => Array
        (
            [auth_id] => 100
            [auth_name] => 后台首页
            [auth_pid] => 0
            [son] => Array
                (
                    [0] => Array
                        (
                            [auth_id] => 122
                            [auth_name] => 数据一览
                            [auth_pid] => 100
                        )
                    [1] => Array
                        (
                            [auth_id] => 123
                            [auth_name] => 更新日志
                            [auth_pid] => 100
                        )
                )
        )
    [1] => Array
        (
            [auth_id] => 116
            [auth_name] => 管理员
            [auth_pid] => 0
            [son] => Array
                (
                    [0] => Array
                        (
                            [auth_id] => 120
                            [auth_name] => 管理员列表
                            [auth_pid] => 116
                        )
                    [1] => Array
                        (
                            [auth_id] => 121
                            [auth_name] => 管理员添加
                            [auth_pid] => 116
                        )
                )
        )
)

这个结果可以很方便的采用json的方式返回给前台，或者接下来采用递归的方式使其变成一维数组，都是很方便的，整个方法的精妙处就在于引用的使用

虽然这个例子使用的只有二级分类，实际上无论几级分类都是很完美的，而且在运行速度上可以说都是很快的，从时间复杂度来说只是一个for循环，比递归不知道高到哪里去了！

更多，参考网站：http://www.php.cn/php-weizijiaocheng-353267.html

转载自https://blog.csdn.net/u012767761/article/details/82776969