PHP技巧实例：树形结构的算法

从喜悦村上转载，以前也读过此文，讲述得还是比较清楚的。
产品分类，多级的树状结构的论坛，邮件列表等许多地方我们都会遇到这样的问题：如何存储多级结构的数据？

在php的应用中，提供后台数据存储的通常是关系型数据库，它能够保存大量的数据，提供高效的数据检索和更新服务。然而关系型数据的基本形式是纵横交错的表，是一个平面的结构，如果要将多级树状结构存储在关系型数据库里就需要进行合理的翻译工作。接下来我会将自己的所见所闻和一些实用的经验和大家探讨一下。

层级结构的数据保存在平面的数据库中基本上有两种常用设计方法：

毗邻目录模式(adjacency list model)
预排序遍历树算法(modified preorder tree traversal algorithm)
我不是计算机专业的，也没有学过什么数据结构的东西，所以这两个名字都是我自己按照字面的意思翻的，如果说错了还请多多指教。

这两个东西听着好像很吓人，其实非常容易理解。这里我用一个简单食品目录作为我们的示例数据。 我们的数据结构是这样的:

food
|
|---fruit
| |
| |---red
| | |
| | |--cherry
| |
| |---yellow
| |
| |--banana
|
|---meat
|
|--beef
|
|--pork
为了照顾那些英文一塌糊涂的php爱好者

food:食物
fruit:水果
red:红色
cherry:樱桃
yellow:黄色
banana:香蕉
meat:肉类
beef:牛肉
pork:猪肉

毗邻目录模式(adjacency list model)

这种模式我们经常用到，很多的教程和书中也介绍过。我们通过给每个节点增加一个属性 parent 来表示这个节点的父节点从而将整个树状结构通过平面的表描述出来。根据这个原则，例子中的数据可以转化成如下的表：

+-----------------------+
| parent | name |
+-----------------------+
| | food |
| food | fruit |
| fruit | green |
| green | pear |
| fruit | red |
| red | cherry |
| fruit | yellow |
| yellow | banana |
| food | meat |
| meat | beef |
| meat | pork |
+-----------------------+
我们看到 pear 是green的一个子节点，green是fruit的一个子节点。而根节点'food'没有父节点。 为了简单地描述这个问题， 这个例子中只用了name来表示一个记录。 在实际的数据库中，你需要用数字的id来标示每个节点，数据库的表结构大概应该像这样：id, parent_id, name, description。有了这样的表我们就可以通过数据库保存整个多级树状结构了。

显示多级树
如果我们需要显示这样的一个多级结构需要一个递归函数。

<?php
// $parent is the parent of the children we want to see
// $level is increased when we go deeper into the tree,
// used to display a nice indented tree

function display_children($parent, $level)
{
// 获得一个 父节点 $parent 的所有子节点
$result = mysql_query('select name from tree '.
'where parent="'.$parent.'";');

// 显示每个子节点
while ($row = mysql_fetch_array($result))
{
// 缩进显示节点名称
echo str_repeat(' ',$level).$row['name']."n";

//再次调用这个函数显示子节点的子节点

display_children($row['name'], $level+1);
}
}
?>
对整个结构的根节点（food）使用这个函数就可以打印出整个多级树结构，由于food是根节点它的父节点是空的，所以这样调用: display_children('',0)。将显示整个树的内容：

food
fruit
red
cherry
yellow
banana
meat
beef
pork
如果你只想显示整个结构中的一部分，比如说水果部分，就可以这样调用：

display_children('fruit',0);

几乎使用同样的方法我们可以知道从根节点到任意节点的路径。比如 cherry 的路径是　"food > fruit > red"。 为了得到这样的一个路径我们需要从最深的一级"cherry"开始， 查询得到它的父节点"red"把它添加到路径中， 然后我们再查询red的父节点并把它也添加到路径中，以此类推直到最高层的"food"

<?php
// $node 是那个最深的节点
function get_path($node)
{
// 查询这个节点的父节点
$result = mysql_query('select parent from tree '.
'where name="'.$node.'";');
$row = mysql_fetch_array($result);

// 用一个数组保存路径
$path = array();

// 如果不是根节点则继续向上查询
// (根节点没有父节点)
if ($row['parent']!='')
{
// the last part of the path to $node, is the name
// of the parent of $node
$path[] = $row['parent'];

// we should add the path to the parent of this node
// to the path
$path = array_merge(get_path($row['parent']), $path);
}

// return the path
return $path;
}
?>
如果对"cherry"使用这个函数：print_r(get_path('cherry'))，就会得到这样的一个数组了：

array
(
[0] => food
[1] => fruit
[2] => red
)
接下来如何把它打印成你希望的格式，就是你的事情了。
缺点：这种方法很简单，容易理解，好上手。但是也有一些缺点。主要是因为运行速度很慢，由于得到每个节点都需要进行数据库查询，数据量大的时候要进行很多查询才能完成一个树。另外由于要进行递归运算，递归的每一级都需要占用一些内存所以在空间利用上效率也比较低。

现在让我们看一看另外一种不使用递归计算，更加快速的方法，这就是预排序遍历树算法(modified preorder tree traversal algorithm) 这种方法大家可能接触的比较少，初次使用也不像上面的方法容易理解，但是由于这种方法不使用递归查询算法，有更高的查询效率。

我们首先将多级数据按照下面的方式画在纸上，在根节点food的左侧写上 1 然后沿着这个树继续向下 在 fruit 的左侧写上 2 然后继续前进，沿着整个树的边缘给每一个节点都标上左侧和右侧的数字。最后一个数字是标在food 右侧的 18。 在下面的这张图中你可以看到整个标好了数字的多级结构。（没有看懂？用你的手指指着数字从1数到18就明白怎么回事了。还不明白，再数一遍，注意要移动你的手指）。
这些数字标明了各个节点之间的关系，"red"的号是3和6，它是 "food" 1-18 的子孙节点。 同样，我们可以看到 所有左值大于2和右值小于11的节点 都是"fruit" 2-11 的子孙节点

1 food 18
|
+---------------------------------------+
| |
2 fruit 11 12 meat 17
| |
+------------------------+ +---------------------+
| | | |
3 red 6 7 yellow 10 13 beef 14 15 pork 16
| |
4 cherry 5 8 banana 9

这样整个树状结构可以通过左右值来存储到数据库中。继续之前，我们看一看下面整理过的数据表。

+-----------------------+-----+-----+
| parent | name | lft | rgt |
+-----------------------+-----+-----+
| | food | 1 | 18 |
| food | fruit | 2 | 11 |
| fruit | red | 3 | 6 |
| red | cherry | 4 | 5 |
| fruit | yellow | 7 | 10 |
| yellow | banana | 8 | 9 |
| food | meat | 12 | 17 |
| meat | beef | 13 | 14 |
| meat | pork | 15 | 16 |
+-----------------------+-----+-----+
注意：由于"left"和"right"在 sql中有特殊的意义，所以我们需要用"lft"和"rgt"来表示左右字段。 另外这种结构中不再需要"parent"字段来表示树状结构。也就是 说下面这样的表结构就足够了。

+------------+-----+-----+
| name | lft | rgt |
+------------+-----+-----+
| food | 1 | 18 |
| fruit | 2 | 11 |
| red | 3 | 6 |
| cherry | 4 | 5 |
| yellow | 7 | 10 |
| banana | 8 | 9 |
| meat | 12 | 17 |
| beef | 13 | 14 |
| pork | 15 | 16 |
+------------+-----+-----+
好了我们现在可以从数据库中获取数据了，例如我们需要得到"fruit"项下的所有所有节点就可以这样写查询语句： select * from tree where lft between 2 and 11; 这个查询得到了以下的结果。

+------------+-----+-----+
| name | lft | rgt |
+------------+-----+-----+
| fruit | 2 | 11 |
| red | 3 | 6 |
| cherry | 4 | 5 |
| yellow | 7 | 10 |
| banana | 8 | 9 |
+------------+-----+-----+
看到了吧，只要一个查询就可以得到所有这些节点。为了能够像上面的递归函数那样显示整个树状结构，我们还需要对这样的查询进行排序。用节点的左值进行排序：

select * from tree where lft between 2 and 11 order by lft asc;
剩下的问题如何显示层级的缩进了。

<?php
function display_tree($root)
{
// 得到根节点的左右值
$result = mysql_query('select lft, rgt from tree '.'where name="'.$root.'";');
$row = mysql_fetch_array($result);

// 准备一个空的右值堆栈
$right = array();

// 获得根基点的所有子孙节点
$result = mysql_query('select name, lft, rgt from tree '.
'where lft between '.$row['lft'].' and '.
$row['rgt'].' order by lft asc;');

// 显示每一行
while ($row = mysql_fetch_array($result))
{
// only check stack if there is one
if (count($right)>0)
{
// 检查我们是否应该将节点移出堆栈
while ($right[count($right)-1]<$row['rgt'])
{
array_pop($right);
}
}

// 缩进显示节点的名称
echo str_repeat(' ',count($right)).$row['name']."n";

// 将这个节点加入到堆栈中
$right[] = $row['rgt'];
}
}
?>
如果你运行一下以上的函数就会得到和递归函数一样的结果。只是我们的这个新的函数可能会更快一些，因为只有2次数据库查询。 要获知一个节点的路径就更简单了，如果我们想知道cherry 的路径就利用它的左右值4和5来做一个查询。

select name from tree where lft < 4 and rgt > 5 order by lft asc;
这样就会得到以下的结果：

+------------+
| name |
+------------+
| food |
| fruit |
| red |
+------------+
那么某个节点到底有多少子孙节点呢？很简单，子孙总数=(右值-左值-1)/2 descendants = (right – left - 1) / 2 不相信？自己算一算啦。用这个简单的公式，我们可以很快的算出"fruit 2-11"节点有4个子孙节点，而"banana 8-9"节点没有子孙节点，也就是说它不是一个父节点了。
很神奇吧？虽然我已经多次用过这个方法，但是每次这样做的时候还是感到很神奇。

这的确是个很好的办法，但是有什么办法能够帮我们建立这样有左右值的数据表呢？这里再介绍一个函数给大家，这个函数可以将name和parent结构的表自动转换成带有左右值的数据表。

<?php
function rebuild_tree($parent, $left) {
// the right value of this node is the left value + 1
$right = $left+1;

// get all children of this node
$result = mysql_query('select name from tree '.
'where parent="'.$parent.'";');
while ($row = mysql_fetch_array($result)) {
// recursive execution of this function for each
// child of this node
// $right is the current right value, which is
// incremented by the rebuild_tree function
$right = rebuild_tree($row['name'], $right);
}

// we've got the left value, and now that we've processed
// the children of this node we also know the right value
mysql_query('update tree set lft='.$left.', rgt='.
$right.' where name="'.$parent.'";');

// return the right value of this node + 1
return $right+1;
}
?>
当然这个函数是一个递归函数，我们需要从根节点开始运行这个函数来重建一个带有左右值的树

rebuild_tree('food',1);
这个函数看上去有些复杂，但是它的作用和手工对表进行编号一样，就是将立体多层结构的转换成一个带有左右值的数据表。

那么对于这样的结构我们该如何增加，更新和删除一个节点呢？ 增加一个节点一般有两种方法：

保留原有的name 和parent结构，用老方法向数据中添加数据，每增加一条数据以后使用rebuild_tree函数对整个结构重新进行一次编号。
效率更高的办法是改变所有位于新节点右侧的数值。举例来说：我们想增加一种新的水果"strawberry"（草莓）它将成为"red"节点的最后一个子节点。首先我们需要为它腾出一些空间。"red"的右值应当从6改成8，"yellow 7-10 "的左右值则应当改成 9-12。 依次类推我们可以得知，如果要给新的值腾出空间需要给所有左右值大于5的节点 （5 是"red"最后一个子节点的右值） 加上2。 所以我们这样进行数据库操作：

update tree set rgt=rgt+2 where rgt>5;
update tree set lft=lft+2 where lft>5;
这样就为新插入的值腾出了空间，现在可以在腾出的空间里建立一个新的数据节点了， 它的左右值分别是6和7

insert into tree set lft=6, rgt=7, name='strawberry';

再做一次查询看看吧！怎么样？很快吧。
好了，现在你可以用两种不同的方法设计你的多级数据库结构了，采用何种方式完全取决于你个人的判断，但是对于层次多数量大的结构我更喜欢第二种方法。如果查询量较小但是需要频繁添加和更新的数据，则第一种方法更为简便。

另外，如果数据库支持的话 你还可以将 rebuild_tree() 和 腾出空间的操作写成数据库端的触发器函数， 在插入和更新的时候自动执行， 这样可以得到更好的运行效率， 而且你添加新节点的sql语句会变得更加简单。
类递归法
posted by 访客 on 2004, may 31 - 9:18am.
我用类 递归法 写了段程序，跟文章中的递归不完全一样
正准备移植到 xoops 中:
http://dev.xoops.org/modules/xfmod/project/?ulink

已经出现内存溢出现象
不过准备继续采用递归法，只是需要继续改进

希望有机会跟各位讨论cms
» reply to this comment
还是两种方法之比较
posted by 访客 on 2004, march 17 - 8:30pm.
　　仔细研究了一下这篇文章，觉得受益非浅，但后来又想了想，觉得有一下问题（为了好记忆，毗邻目录模式我称为递归的方法，预排序遍历树算法我称为预排序树的方法）：

1、两种方法比较大的区别是递归是在查询的时候要用到堆栈进行递归，预排序树则是在更新节点时要进行半数（指所插入节点的后半部分）节点的更新。虽然您也说了，如果节点多了，更新又频繁，预排序树效率会降低，采用递归会好些，而如果节点层次较多的话，首先递归会导致堆栈溢出，再者递归本身效率就不高，加上每一层递归都要操作数据库，总体效果也不会理想。我目前的做法是一次性把数据全取出来，然后对数组进行递归操作，会好一些；再进一步改进的话，可以为每行记录增加一个root根节点（目前是只记录相邻的父节点），这样在查找分支树时效率就会比较高了，更新树的时候也是十分便捷的，应该是一种比较好的方式。

2、改进递归的方式，文章中在计算预排序树节点的左右值的时候其实也用到了一种遍历方式，通过数组替代堆栈，手工实现压栈和弹出；这种方法如果引用到递归算法中，在进行递归的时候也用数组替代堆栈的话，也可以提高递归的效率的。

3、并发，如果考虑到并发的情况，尤其是更新树的时候，预排序树大面积更新节点信息的方法需要额外注意采用加锁和事务的机制保证数据一致性。

4、多根节点或者多父节点的情况，在这种情况下，显然就不是一个标准的二叉树或者多叉树了，预排序树算法需要进行比较大的改进才能适应，而递归的方法则应用自如，所以在这种情况下，递归的适应性较强。这是当然的了，因为递归的方法就是链表的一种形式，树、图都可以用链表来表达，当然适应力强了。

5、直观，如果不用程序操作，直接观察数据库中存储的数据的话，显然递归方式下存储的数据比较直观，而预排序树的数据很难直接阅读（针对层次关系来说），这在数据交换中是不是会有影响呢？

　　总体来说，我个人比较喜欢用递归的方法，但一直担心递归对效率的影响，所幸还没有接触过规模较大的分类层次，递归用数组替代堆栈会是一种比较好的改进方法。而预排序树不失为一种解决简单树的高效方法，用习惯了，也应该是非常出色的，尤其是它从叶子节点到根节点的反向查找非常方便。

fwolf
www.fwolf.com
» reply to this comment
非常高兴看到你的回复
posted by shuke on 2004, march 18 - 5:47am.
非常高兴你这么认真的读完这篇文章。这篇文章其实是原来发表在sitepoint.com上的，我把它翻译了一下，希望给希望初学入门的朋友介绍一些方法，抛砖引玉。你的方法也很好，有机会我会试一下的。（如果你有兴趣的话，何不就上面的例子把你的方法和具体实现的代码也写成教程发出来吧，这样大家就用更加实际的例子来模仿了）如果你对数据库中保存多级结构有兴趣研究的话，这里还有两个连接也很不错可以作为参考：
介绍了常见的4中方法
一次查询，数组排序的脚本我想你的脚本肯定比这个强。
另外我看到你也用drupal，它还有一个高级功能叫分布式用户验证系统，只要在任何一个drupal的站点注册以后就可以登录访问其它的drupal站点了。挺有意思的。
祝好！
» reply to this comment
用循环来建树已经实现了
posted by 访客 on 2004, march 25 - 10:10pm.
你上次提供的资料我已经都看过了，不过老实说，第一篇文章里没有太多新东西，或许是我没看太明白吧，第二个居然是php3写的，程序结构没有细看，用到太多的函数交叉。
正好我在一个系统中用户角色要用到分级，按照数组的思路就把遍历写了下来，没有时间整理，先放到这里你看看吧，数据库用的是adodb，程序是直接从系统中摘出来的，希望能够描述得清楚，主要是利用了php强大的数组操作，用循环来进行递归。注释里是一种相近的方法，只是处理结果的时机不同而已。

<?php
/**
* 显示列表
* @access public
*/
function displist()
{
//不缩进的显示方式
// $this->misdisplistindex = true;
// echo('<p align="right"><a href="?action=new&part=role">增加新角色</a>　　</p>'); _fcksavedurl=""?action=new&part=role">增加新角色</a>　　</p>');"
//
// $this->mlisttitle = '用户角色列表';
// $this->setdataoption('list');
//
// $this->setquerytable( array($this->mtableuserrole) );
//
// //查询顺序
// $this->setqueryorder( 'asc', $this->mtableuserrole, 'sequence' );
//
// $this->query('list');
// parent::displist();

// //另外一种显示方式，用数组作为堆栈，a: 压栈时存role，压完就删除source
// $this->checkproperty('mrdb');
// $this->checkproperty('mrsql');
// $this->mrsql->select('role, title, parent');
// $this->mrsql->from($this->mtableuserrole);
// $this->mrsql->orderby('parent, sequence');
// $this->mrs = $this->mrdb->execute($this->mrsql->sql());
// if (0 < count($this->mrs))
// {
// $source = & $this->mrs->getarray(); //数字索引
// $stack = array(''); //堆栈
// $stacki = array(-1); //和堆栈对应，记录堆栈中数据在树中的层次
// $target = array();
// while (0 < count($stack))
// {
// $item = array_shift($stack);
// $lev = array_shift($stacki);
// if (!empty($item))
// {
// //在这里把加工过的数据放到target数组
// array_push($target, str_repeat(' ', $lev) . $item);
// //$s1 = str_repeat(' ', $lev) . $item;
// }
// $del = array(); //要从$source中删除的节点
// $ar = array(); //需要添加到堆栈中的节点
// foreach ($source as $key=>$val)
// {
// //寻找匹配的子节点
// if (empty($item))
// {
// $find = empty($source[$key]['parent']);
// }
// else
// {
// $find = ($item == $source[$key]['parent']);
// }
// if ($find)
// {
// array_unshift($ar, $source[$key]['role']);
// $del[] = $key;
// }
// }
// foreach ($ar as $val)
// {
// array_unshift($stack, $val);
// array_unshift($stacki, $lev + 1);
// }
// foreach ($del as $val)
// {
// unset($source[$val]);
// }
// echo(implode(', ', $stack) . '<br />' . implode(', ', $stacki) . '<br />' . implode(', ', $target) . '<br /><br />');
// }
// debug_array();
// }
// else
// {
// echo('<center>没有检索到数据</center>');
// }

//另外一种显示方式，用数组作为堆栈，b: 压栈时存数组索引，出栈并使用完后再删除source
$this->checkproperty('mrdb');
$this->checkproperty('mrsql');
$this->mrsql->select('role, title, parent');
$this->mrsql->from($this->mtableuserrole);
$this->mrsql->orderby('parent, sequence');
$this->mrs = $this->mrdb->execute($this->mrsql->sql());
if (!empty($this->mrs) && !$this->mrs->eof)
{
$source = & $this->mrs->getarray(); //数字索引
$stack = array(-1); //堆栈
$stacki = array(-1); //和堆栈对应，记录堆栈中数据在树中的层次
$target = array();
while (0 < count($stack))
{
$item = array_shift($stack);
$lev = array_shift($stacki);
if (-1 != $item)
{
//在这里把加工过的数据放到target数组
$s1 = str_repeat('  ', $lev) . '<a href="?action=disp&part=role&role=' . $source[$item]['role'] . '">' . $source[$item]['title'] . '</a>';
$s2 = '<a href="?action=edit&part=role&role=' . $source[$item]['role'] . '">编辑</a>　<a href="?action=delete&part=role&role=' . $source[$item]['role'] . '">删除</a>';
array_push($target, array($s1, $s2));
}
$del = array(); //要从$source中删除的节点
$ar = array(); //需要添加到堆栈中的节点
foreach ($source as $key=>$val)
{
//寻找匹配的子节点
if (-1 == $item)
{
$find = empty($source[$key]['parent']);
}
else
{
$find = ($source[$item]['role'] == $source[$key]['parent']);
}
if ($find)
{
array_unshift($ar, $key);
}
}
foreach ($ar as $val)
{
array_unshift($stack, $val);
array_unshift($stacki, $lev + 1);
}
//从source中删除
unset($source[$item]);
//echo(implode(', ', $stack) . '<br />' . implode(', ', $stacki) . '<br />' . implode(', ', $target) . '<br /><br />');
}
//输出
echo('<p align="right"><a href="?action=new&part=role">增加新角色</a>　　</p>');
array_unshift($target, array('角色', '操作'));
$this->checkproperty('mrlt');
$this->mrlt->setdata($target);
$this->mrlt->mlisttitle = '用户角色列表';
$this->mrlt->misdispindex = false;
$this->mrlt->disp();
}
else
{
echo('<center>没有检索到数据</center>');
}
} // end of function displist
?>