将一系列父子关系转换为分层树？

113

这需要一个非常基本的递归函数来将子对/父对解析为树结构，并使用另一个递归函数将其打印出来。只有一个函数就足够了，但为了清楚起见，这里有两个函数（在这个答案的最后可以找到一个组合函数）。

首先初始化父/子对的数组：

$tree = array(
    'H' => 'G', 
    'F' => 'G', 
    'G' => 'D', 
    'E' => 'D', 
    'A' => 'E', 
    'B' => 'C', 
    'C' => 'E', 
    'D' => null 
);

然后，将分析该数组到一个分层树结构的功能：

function parseTree($tree, $root = null) { 
    $return = array(); 
    # Traverse the tree and search for direct children of the root 
    foreach($tree as $child => $parent) { 
     # A direct child is found 
     if($parent == $root) { 
      # Remove item from tree (we don't need to traverse this again) 
      unset($tree[$child]); 
      # Append the child into result array and parse its children 
      $return[] = array(
       'name' => $child, 
       'children' => parseTree($tree, $child) 
      ); 
     } 
    } 
    return empty($return) ? null : $return;  
}

和一个函数遍历该树打印出一个无序列表：

function printTree($tree) { 
    if(!is_null($tree) && count($tree) > 0) { 
     echo '<ul>'; 
     foreach($tree as $node) { 
      echo '<li>'.$node['name']; 
      printTree($node['children']); 
      echo '</li>'; 
     } 
     echo '</ul>'; 
    } 
}

而实际用法：

$result = parseTree($tree); 
printTree($result);

这里是$result内容：

Array(
    [0] => Array(
     [name] => D 
     [children] => Array(
      [0] => Array(
       [name] => G 
       [children] => Array(
        [0] => Array(
         [name] => H 
         [children] => NULL 
        ) 
        [1] => Array(
         [name] => F 
         [children] => NULL 
        ) 
       ) 
      ) 
      [1] => Array(
       [name] => E 
       [children] => Array(
        [0] => Array(
         [name] => A 
         [children] => NULL 
        ) 
        [1] => Array(
         [name] => C 
         [children] => Array(
          [0] => Array(
           [name] => B 
           [children] => NULL 
          ) 
         ) 
        ) 
       ) 
      ) 
     ) 
    ) 
)

如果你想多一点效率，可以结合使用这些功能集于一体，减少重复所做的数量：

function parseAndPrintTree($root, $tree) { 
    $return = array(); 
    if(!is_null($tree) && count($tree) > 0) { 
     echo '<ul>'; 
     foreach($tree as $child => $parent) { 
      if($parent == $root) {      
       unset($tree[$child]); 
       echo '<li>'.$child; 
       parseAndPrintTree($child, $tree); 
       echo '</li>'; 
      } 
     } 
     echo '</ul>'; 
    } 
}

你只会在这样一个小的数据集上保存8次迭代，但是在更大的数据集上可能会有所不同。

来源

2010-05-26 19:04:46

+1

大肚。我怎样才能改变printTree函数不直接回应树的html，但保存所有的输出html到一个变量并返回它？谢谢 – Enrique 2012-12-17 13:58:59

+0

嗨，我认为函数声明必须是parseAndPrintTree（$ tree，$ root = null）并且递归调用应该是parseAndPrintTree（$ child，$ tree）; 致以问候 – razor7 2014-04-25 20:52:02

2

好，解析成上行线路及LIS，这将是这样的：

$array = array (
    'H' => 'G' 
    'F' => 'G' 
    'G' => 'D' 
    'E' => 'D' 
    'A' => 'E' 
    'B' => 'C' 
    'C' => 'E' 
    'D' => 'NULL' 
); 


recurse_uls ($array, 'NULL'); 

function recurse_uls ($array, $parent) 
{ 
    echo '<ul>'; 
    foreach ($array as $c => $p) { 
     if ($p != $parent) continue; 
     echo '<li>'.$c.'</li>'; 
     recurse_uls ($array, $c); 
    } 
    echo '</ul>'; 
}

但我很想看到，不要求你通过数组所以经常要迭代的解决方案.. 。

来源

2010-05-26 19:05:16 arnorhs

8

首先，我会变成键值对的直数组分级阵列

function convertToHeiarchical(array $input) { 
    $parents = array(); 
    $root = array(); 
    $children = array(); 
    foreach ($input as $item) { 
     $parents[$item['id']] = &$item; 
     if ($item['parent_id']) { 
      if (!isset($children[$item['parent_id']])) { 
       $children[$item['parent_id']] = array(); 
      } 
      $children[$item['parent_id']][] = &$item; 
     } else { 
      $root = $item['id']; 
     } 
    } 
    foreach ($parents as $id => &$item) { 
     if (isset($children[$id])) { 
      $item['children'] = $children[$id]; 
     } else { 
      $item['children'] = array(); 
     } 
    } 
    return $parents[$root]; 
}

那将可以PARENT_ID和id平面数组转换成一个层次：

$item = array(
    'id' => 'A', 
    'blah' => 'blah', 
    'children' => array(
     array(
      'id' => 'B', 
      'blah' => 'blah', 
      'children' => array(
       array(
        'id' => 'C', 
        'blah' => 'blah', 
        'children' => array(), 
       ), 
      ), 
      'id' => 'D', 
      'blah' => 'blah', 
      'children' => array(
       array(
        'id' => 'E', 
        'blah' => 'blah', 
        'children' => array(), 
       ), 
      ), 
     ), 
    ), 
);

然后，只需创建一个渲染功能：

function renderItem($item) { 
    $out = "Your OUtput For Each Item Here"; 
    $out .= "<ul>"; 
    foreach ($item['children'] as $child) { 
     $out .= "<li>".renderItem($child)."</li>"; 
    } 
    $out .= "</ul>"; 
    return $out; 
}

来源

2010-05-26 19:08:55 ircmaxell

2

这就是我想出了：

个

$arr = array(
      'H' => 'G', 
      'F' => 'G', 
      'G' => 'D', 
      'E' => 'D', 
      'A' => 'E', 
      'B' => 'C', 
      'C' => 'E', 
      'D' => null); 

    $nested = parentChild($arr); 
    print_r($nested); 

    function parentChild(&$arr, $parent = false) { 
     if(!$parent) { //initial call 
     $rootKey = array_search(null, $arr); 
     return array($rootKey => parentChild($arr, $rootKey)); 
     }else { // recursing through 
     $keys = array_keys($arr, $parent); 
     $piece = array(); 
     if($keys) { // found children, so handle them 
      if(!is_array($keys)) { // only one child 
      $piece = parentChild($arr, $keys); 
      }else{ // multiple children 
      foreach($keys as $key){ 
       $piece[$key] = parentChild($arr, $key); 
      } 
      } 
     }else { 
      return $parent; //return the main tag (no kids) 
     } 
     return $piece; // return the array built via recursion 
     } 
    }

输出：

Array 
(
    [D] => Array 
     (
      [G] => Array 
       (
        [H] => H 
        [F] => F 
       ) 

      [E] => Array 
       (
        [A] => A 
        [C] => Array 
         (
          [B] => B 
         )  
       )  
     )  
)

来源

2010-05-26 19:21:35

48

然而，另一个函数来使树（没有递归参与，使用的引用代替）：

$array = array('H' => 'G', 'F' => 'G', ..., 'D' => null); 

function to_tree($array) 
{ 
    $flat = array(); 
    $tree = array(); 

    foreach ($array as $child => $parent) { 
     if (!isset($flat[$child])) { 
      $flat[$child] = array(); 
     } 
     if (!empty($parent)) { 
      $flat[$parent][$child] =& $flat[$child]; 
     } else { 
      $tree[$child] =& $flat[$child]; 
     } 
    } 

    return $tree; 
}

返回一个分层阵列像这样的：

Array(
    [D] => Array(
     [G] => Array(
      [H] => Array() 
      [F] => Array() 
     ) 
     ... 
    ) 
)

其中ca使用递归函数可以很容易地将其打印为HTML列表。

来源

2010-05-26 19:34:28

+0

+1 - 非常聪明。尽管我发现递归解决方案更合乎逻辑。但我更喜欢你的函数的输出格式。 – Eric 2010-05-26 20:20:38

26

另一种更简化的方式将$tree中的扁平结构转换为层次结构。仅需要一个临时数组揭露它：

// add children to parents 
$flat = array(); # temporary array 
foreach ($tree as $name => $parent) 
{ 
    $flat[$name]['name'] = $name; # self 
    if (NULL === $parent) 
    { 
     # no parent, is root element, assign it to $tree 
     $tree = &$flat[$name]; 
    } 
    else 
    { 
     # has parent, add self as child  
     $flat[$parent]['children'][] = &$flat[$name]; 
    } 
} 
unset($flat);

这是所有获得的层次结构成多维数组：

Array 
(
    [children] => Array 
     (
      [0] => Array 
       (
        [children] => Array 
         (
          [0] => Array 
           (
            [name] => H 
           ) 

          [1] => Array 
           (
            [name] => F 
           ) 

         ) 

        [name] => G 
       ) 

      [1] => Array 
       (
        [name] => E 
        [children] => Array 
         (
          [0] => Array 
           (
            [name] => A 
           ) 

          [1] => Array 
           (
            [children] => Array 
             (
              [0] => Array 
               (
                [name] => B 
               ) 

             ) 

            [name] => C 
           ) 

         ) 

       ) 

     ) 

    [name] => D 
)

输出是，如果你想避免递归少微不足道（可能是一个大结构的负担）。

我一直想解决输出数组的UL/LI“难题”。困境是，每个项目都不知道孩子是否会跟进或需要关闭多少前面的元素。在另一个答案我已经解决了，通过使用RecursiveIteratorIterator并寻找getDepth()和我自己写的Iterator提供的其他元信息：Getting nested set model into a <ul> but hiding “closed” subtrees。 answer显示，与迭代器，你很灵活。

但是这是一个预先排序的列表，所以不适合您的示例。此外，我一直想解决这个问题的一种标准树结构和HTML的<ul>和<li>元素。

我想出的基本概念是：

TreeNode - 文摘每个元素成简单TreeNode类型，可以提供它的值（例如Name），以及是否有孩子。
TreeNodesIterator - A RecursiveIterator能够遍历这些TreeNodes的集合（数组）。这很简单，因为TreeNode类型已经知道它是否有孩子和哪些孩子。
RecursiveListIterator - 有当递归遍历任何一种RecursiveIterator所需的所有事件RecursiveIteratorIterator：
- beginIteration/endIteration - 开始和主列表的末尾。
- beginElement/endElement - 每个元素的开始和结束。
- beginChildren/endChildren - 每个子列表的开始和结束。这个RecursiveListIterator只以函数调用的形式提供这些事件。儿童名单，因为它是典型的<ul><li>名单，被打开和关闭它的父母<li>元素。因此endElement事件在相应的endChildren事件之后被触发。这可以改变或可配置，以扩大使用这个类。这些事件是作为函数调用分发给装饰器对象的，然后将事情分开。
ListDecorator - A “装饰” 类，它仅仅是一个RecursiveListIterator事件的接收器。

我从主输出逻辑开始。两者现在分层$tree阵列，最终代码如下所示：

$root = new TreeNode($tree); 
$it = new TreeNodesIterator(array($root)); 
$rit = new RecursiveListIterator($it); 
$decor = new ListDecorator($rit); 
$rit->addDecorator($decor); 

foreach($rit as $item) 
{ 
    $inset = $decor->inset(1); 
    printf("%s%s\n", $inset, $item->getName()); 
}

首先，让我们看看，简单地包装了<ul>和<li>元素，并在判决的表结构如何输出的ListDecorator：

class ListDecorator 
{ 
    private $iterator; 
    public function __construct(RecursiveListIterator $iterator) 
    { 
     $this->iterator = $iterator; 
    } 
    public function inset($add = 0) 
    { 
     return str_repeat(' ', $this->iterator->getDepth()*2+$add); 
    }

构造函数接受它正在处理的列表迭代器。 inset只是输出的很好缩进的帮助函数。剩下的只是每个事件的输出功能：

public function beginElement() 
    { 
     printf("%s<li>\n", $this->inset()); 
    } 
    public function endElement() 
    { 
     printf("%s</li>\n", $this->inset()); 
    } 
    public function beginChildren() 
    { 
     printf("%s<ul>\n", $this->inset(-1)); 
    } 
    public function endChildren() 
    { 
     printf("%s</ul>\n", $this->inset(-1)); 
    } 
    public function beginIteration() 
    { 
     printf("%s<ul>\n", $this->inset()); 
    } 
    public function endIteration() 
    { 
     printf("%s</ul>\n", $this->inset()); 
    } 
}

考虑到这些输出功能，这是主要的输出总结/再循环，我通过它一步一步：

$root = new TreeNode($tree);

创建一个将被用于在开始迭代根TreeNode：

$it = new TreeNodesIterator(array($root));

这TreeNodesIterator是RecursiveIterator，使递归迭代过第e单一$root节点。它作为一个数组传递，因为该类需要迭代并允许与一组子元素重用，这也是一个元素数组。

$rit = new RecursiveListIterator($it);

这RecursiveListIterator是RecursiveIteratorIterator提供上述事件。为了利用它，可以仅设置一个ListDecorator需要（上面的类），并分配有addDecorator：

$decor = new ListDecorator($rit); 
$rit->addDecorator($decor);

然后所有设置，使其仅foreach于其上，并输出每个节点：

foreach($rit as $item) 
{ 
    $inset = $decor->inset(1); 
    printf("%s%s\n", $inset, $item->getName()); 
}

如本例所示，整个输出逻辑封装在ListDecorator类和此单个foreach中。整个递归遍历已被完全封装成提供堆栈过程的SPL递归迭代器，这意味着在内部不会进行递归函数调用。

基于事件的ListDecorator允许您专门修改输出并为同一数据结构提供多种类型的列表。甚至可以在阵列数据已被封装到TreeNode中时更改输入。

的完整代码例如：

<?php 
namespace My; 

$tree = array('H' => 'G', 'F' => 'G', 'G' => 'D', 'E' => 'D', 'A' => 'E', 'B' => 'C', 'C' => 'E', 'D' => null); 

// add children to parents 
$flat = array(); # temporary array 
foreach ($tree as $name => $parent) 
{ 
    $flat[$name]['name'] = $name; # self 
    if (NULL === $parent) 
    { 
     # no parent, is root element, assign it to $tree 
     $tree = &$flat[$name]; 
    } 
    else 
    { 
     # has parent, add self as child  
     $flat[$parent]['children'][] = &$flat[$name]; 
    } 
} 
unset($flat); 

class TreeNode 
{ 
    protected $data; 
    public function __construct(array $element) 
    { 
     if (!isset($element['name'])) 
      throw new InvalidArgumentException('Element has no name.'); 

     if (isset($element['children']) && !is_array($element['children'])) 
      throw new InvalidArgumentException('Element has invalid children.'); 

     $this->data = $element; 
    } 
    public function getName() 
    { 
     return $this->data['name']; 
    } 
    public function hasChildren() 
    { 
     return isset($this->data['children']) && count($this->data['children']); 
    } 
    /** 
    * @return array of child TreeNode elements 
    */ 
    public function getChildren() 
    {   
     $children = $this->hasChildren() ? $this->data['children'] : array(); 
     $class = get_called_class(); 
     foreach($children as &$element) 
     { 
      $element = new $class($element); 
     } 
     unset($element);   
     return $children; 
    } 
} 

class TreeNodesIterator implements \RecursiveIterator 
{ 
    private $nodes; 
    public function __construct(array $nodes) 
    { 
     $this->nodes = new \ArrayIterator($nodes); 
    } 
    public function getInnerIterator() 
    { 
     return $this->nodes; 
    } 
    public function getChildren() 
    { 
     return new TreeNodesIterator($this->nodes->current()->getChildren()); 
    } 
    public function hasChildren() 
    { 
     return $this->nodes->current()->hasChildren(); 
    } 
    public function rewind() 
    { 
     $this->nodes->rewind(); 
    } 
    public function valid() 
    { 
     return $this->nodes->valid(); 
    } 
    public function current() 
    { 
     return $this->nodes->current(); 
    } 
    public function key() 
    { 
     return $this->nodes->key(); 
    } 
    public function next() 
    { 
     return $this->nodes->next(); 
    } 
} 

class RecursiveListIterator extends \RecursiveIteratorIterator 
{ 
    private $elements; 
    /** 
    * @var ListDecorator 
    */ 
    private $decorator; 
    public function addDecorator(ListDecorator $decorator) 
    { 
     $this->decorator = $decorator; 
    } 
    public function __construct($iterator, $mode = \RecursiveIteratorIterator::SELF_FIRST, $flags = 0) 
    { 
     parent::__construct($iterator, $mode, $flags); 
    } 
    private function event($name) 
    { 
     // event debug code: printf("--- %'.-20s --- (Depth: %d, Element: %d)\n", $name, $this->getDepth(), @$this->elements[$this->getDepth()]); 
     $callback = array($this->decorator, $name); 
     is_callable($callback) && call_user_func($callback); 
    } 
    public function beginElement() 
    { 
     $this->event('beginElement'); 
    } 
    public function beginChildren() 
    { 
     $this->event('beginChildren'); 
    } 
    public function endChildren() 
    { 
     $this->testEndElement(); 
     $this->event('endChildren'); 
    } 
    private function testEndElement($depthOffset = 0) 
    { 
     $depth = $this->getDepth() + $depthOffset;  
     isset($this->elements[$depth]) || $this->elements[$depth] = 0; 
     $this->elements[$depth] && $this->event('endElement'); 

    } 
    public function nextElement() 
    { 
     $this->testEndElement(); 
     $this->event('{nextElement}'); 
     $this->event('beginElement');  
     $this->elements[$this->getDepth()] = 1; 
    } 
    public function beginIteration() 
    { 
     $this->event('beginIteration'); 
    } 
    public function endIteration() 
    { 
     $this->testEndElement(); 
     $this->event('endIteration');  
    } 
} 

class ListDecorator 
{ 
    private $iterator; 
    public function __construct(RecursiveListIterator $iterator) 
    { 
     $this->iterator = $iterator; 
    } 
    public function inset($add = 0) 
    { 
     return str_repeat(' ', $this->iterator->getDepth()*2+$add); 
    } 
    public function beginElement() 
    { 
     printf("%s<li>\n", $this->inset(1)); 
    } 
    public function endElement() 
    { 
     printf("%s</li>\n", $this->inset(1)); 
    } 
    public function beginChildren() 
    { 
     printf("%s<ul>\n", $this->inset()); 
    } 
    public function endChildren() 
    { 
     printf("%s</ul>\n", $this->inset()); 
    } 
    public function beginIteration() 
    { 
     printf("%s<ul>\n", $this->inset()); 
    } 
    public function endIteration() 
    { 
     printf("%s</ul>\n", $this->inset()); 
    } 
} 


$root = new TreeNode($tree); 
$it = new TreeNodesIterator(array($root)); 
$rit = new RecursiveListIterator($it); 
$decor = new ListDecorator($rit); 
$rit->addDecorator($decor); 

foreach($rit as $item) 
{ 
    $inset = $decor->inset(2); 
    printf("%s%s\n", $inset, $item->getName()); 
}

Outpupt：

<ul> 
    <li> 
    D 
    <ul> 
     <li> 
     G 
     <ul> 
      <li> 
      H 
      </li> 
      <li> 
      F 
      </li> 
     </ul> 
     </li> 
     <li> 
     E 
     <ul> 
      </li> 
      <li> 
      A 
      </li> 
      <li> 
      C 
      <ul> 
       <li> 
       B 
       </li> 
      </ul> 
      </li> 
     </ul> 
     </li> 
    </ul> 
    </li> 
</ul>

Demo (PHP 5.2 variant)

一种可能的变体将是遍历任何RecursiveIterator并提供对所有事件的迭代的迭代器可能发生。然后，foreach循环内的开关/情况可以处理事件。

相关：

来源

2011-11-27 10:57:12 hakre

+2

由于这个解决方案的“精心设计” - 与前面的例子相比，“更简化的方式”究竟如何 - 它看起来像是针对同一问题的过度设计的解决方案 – Andre 2014-11-09 10:10:31

+0

@Andre：通过封装IIRC的等级。在另一个相关的答案中，我有一个完全没有封装的代码片段，这个代码片段要小得多，因此可能会根据POV“更简化”。 – hakre 2015-09-03 11:39:25

+0

@hakre如何修改“ListDecorator”类以将“id”添加到LI，即从树数组中获取？ – Gangesh 2016-06-24 20:02:47

0

如何创建动态树视图和菜单

第1步：首先，我们将在MySQL数据库中创建树状表。此表包含四个column.id是任务ID，name是任务名称。

- 
-- Table structure for table `treeview_items` 
-- 

CREATE TABLE IF NOT EXISTS `treeview_items` (
    `id` int(11) NOT NULL AUTO_INCREMENT, 
    `name` varchar(200) NOT NULL, 
    `title` varchar(200) NOT NULL, 
    `parent_id` varchar(11) NOT NULL, 
    PRIMARY KEY (`id`) 
) ENGINE=InnoDB DEFAULT CHARSET=latin1 AUTO_INCREMENT=7 ; 

-- 
-- Dumping data for table `treeview_items` 
-- 

INSERT INTO `treeview_items` (`id`, `name`, `title`, `parent_id`) VALUES 
(1, 'task1', 'task1title', '2'), 
(2, 'task2', 'task2title', '0'), 
(3, 'task3', 'task1title3', '0'), 
(4, 'task4', 'task2title4', '3'), 
(5, 'task4', 'task1title4', '3'), 
(6, 'task5', 'task2title5', '5');

步骤2：树视图递归方法我已低于该调用递归如果当前的任务id为大于先前任务ID更大树createTreeView（）方法创建。

function createTreeView($array, $currentParent, $currLevel = 0, $prevLevel = -1) { 

foreach ($array as $categoryId => $category) { 

if ($currentParent == $category['parent_id']) {      
    if ($currLevel > $prevLevel) echo " <ol class='tree'> "; 

    if ($currLevel == $prevLevel) echo " </li> "; 

    echo '<li> <label for="subfolder2">'.$category['name'].'</label> <input type="checkbox" name="subfolder2"/>'; 

    if ($currLevel > $prevLevel) { $prevLevel = $currLevel; } 

    $currLevel++; 

    createTreeView ($array, $categoryId, $currLevel, $prevLevel); 

    $currLevel--;    
    } 

} 

if ($currLevel == $prevLevel) echo " </li> </ol> "; 

}

第3步：创建索引文件以显示树视图。这是treeview示例的主要文件，在这里我们将调用具有所需参数的createTreeView（）方法。

<body> 
<link rel="stylesheet" type="text/css" href="_styles.css" media="screen"> 
<?php 
mysql_connect('localhost', 'root'); 
mysql_select_db('test'); 


$qry="SELECT * FROM treeview_items"; 
$result=mysql_query($qry); 


$arrayCategories = array(); 

while($row = mysql_fetch_assoc($result)){ 
$arrayCategories[$row['id']] = array("parent_id" => $row['parent_id'], "name" =>      
$row['name']); 
    } 
?> 
<div id="content" class="general-style1"> 
<?php 
if(mysql_num_rows($result)!=0) 
{ 
?> 
<?php 

createTreeView($arrayCategories, 0); ?> 
<?php 
} 
?> 

</div> 
</body>

4步：创建CSS文件style.css中在这里，我们会写所有的CSS相关的类，目前我使用的顺序列表创建树视图。你也可以在这里改变图像路径。

img { border: none; } 
input, select, textarea, th, td { font-size: 1em; } 

/* CSS Tree menu styles */ 
ol.tree 
{ 
    padding: 0 0 0 30px; 
    width: 300px; 
} 
    li 
    { 
     position: relative; 
     margin-left: -15px; 
     list-style: none; 
    } 
    li.file 
    { 
     margin-left: -1px !important; 
    } 
     li.file a 
     { 
      background: url(document.png) 0 0 no-repeat; 
      color: #fff; 
      padding-left: 21px; 
      text-decoration: none; 
      display: block; 
     } 
     li.file a[href *= '.pdf'] { background: url(document.png) 0 0 no-repeat; } 
     li.file a[href *= '.html'] { background: url(document.png) 0 0 no-repeat; } 
     li.file a[href $= '.css'] { background: url(document.png) 0 0 no-repeat; } 
     li.file a[href $= '.js']  { background: url(document.png) 0 0 no-repeat; } 
    li input 
    { 
     position: absolute; 
     left: 0; 
     margin-left: 0; 
     opacity: 0; 
     z-index: 2; 
     cursor: pointer; 
     height: 1em; 
     width: 1em; 
     top: 0; 
    } 
     li input + ol 
     { 
      background: url(toggle-small-expand.png) 40px 0 no-repeat; 
      margin: -0.938em 0 0 -44px; /* 15px */ 
      height: 1em; 
     } 
     li input + ol > li { display: none; margin-left: -14px !important; padding-left: 1px; } 
    li label 
    { 
     background: url(folder-horizontal.png) 15px 1px no-repeat; 
     cursor: pointer; 
     display: block; 
     padding-left: 37px; 
    } 

    li input:checked + ol 
    { 
     background: url(toggle-small.png) 40px 5px no-repeat; 
     margin: -1.25em 0 0 -44px; /* 20px */ 
     padding: 1.563em 0 0 80px; 
     height: auto; 
    } 
     li input:checked + ol > li { display: block; margin: 0 0 0.125em; /* 2px */} 
     li input:checked + ol > li:last-child { margin: 0 0 0.063em; /* 1px */ }

More Details

来源

2014-07-24 08:04:34

4

虽然Alexander-Konstantinov的解决方案可能似乎不容易在第一次读，它既是天才，在性能方面成倍更好，这应该被选为最佳答案。

感谢队友，我做了一个基准，以您的荣誉来比较本文中介绍的两种解决方案。

我有一个@ 250k的扁平树，有6个层次，我必须转换，我正在寻找更好的方法来避免递归迭代。

递归VS参考：

// Generate a 6 level flat tree 
$root = null; 
$lvl1 = 13; 
$lvl2 = 11; 
$lvl3 = 7; 
$lvl4 = 5; 
$lvl5 = 3; 
$lvl6 = 1;  
$flatTree = []; 
for ($i = 1; $i <= 450000; $i++) { 
    if ($i % 3 == 0) { $lvl5 = $i; $flatTree[$lvl6] = $lvl5; continue; } 
    if ($i % 5 == 0) { $lvl4 = $i; $flatTree[$lvl5] = $lvl4; continue; } 
    if ($i % 7 == 0) { $lvl3 = $i; $flatTree[$lvl3] = $lvl2; continue; } 
    if ($i % 11 == 0) { $lvl2 = $i; $flatTree[$lvl2] = $lvl1; continue; } 
    if ($i % 13 == 0) { $lvl1 = $i; $flatTree[$lvl1] = $root; continue; } 
    $lvl6 = $i; 
} 

echo 'Array count: ', count($flatTree), PHP_EOL; 

// Reference function 
function treeByReference($flatTree) 
{ 
    $flat = []; 
    $tree = []; 

    foreach ($flatTree as $child => $parent) { 
     if (!isset($flat[$child])) { 
      $flat[$child] = []; 
     } 
     if (!empty($parent)) { 
      $flat[$parent][$child] =& $flat[$child]; 
     } else { 
      $tree[$child] =& $flat[$child]; 
     } 
    } 

    return $tree; 
} 

// Recursion function 
function treeByRecursion($flatTree, $root = null) 
{ 
    $return = []; 
    foreach($flatTree as $child => $parent) { 
     if ($parent == $root) { 
      unset($flatTree[$child]); 
      $return[$child] = treeByRecursion($flatTree, $child); 
     } 
    } 
    return $return ?: []; 
} 

// Benchmark reference 
$t1 = microtime(true); 
$tree = treeByReference($flatTree); 
echo 'Reference: ', (microtime(true) - $t1), PHP_EOL; 

// Benchmark recursion 
$t2 = microtime(true); 
$tree = treeByRecursion($flatTree); 
echo 'Recursion: ', (microtime(true) - $t2), PHP_EOL;

输出言自明：

Array count: 255493 
Reference: 0.3259289264679 (less than 0.4s) 
Recursion: 6604.9865279198 (almost 2h)

来源

2015-12-04 11:53:33 NTT

将一系列父子关系转换为分层树？

回答

相关问题