Question

我有一个数组数组，用于保存图中节点之间的父子关系。每个嵌套数组的格式为

array( 0 => parent_node_id, 1 => child_node_id )

所以在这个数组中：

0 => array(
   0 => 1
   1 => 3
)

两个节点分别为1和3，节点1和节点3之间存在父子关系（外部数组索引0无关紧要。）

1 => array(
   0 => 3
   1 => 5
),

表示节点3和节点5之间的父子关系（1无关紧要）。

这是父子关系数组（注意外部数组的数组索引（0,1,2,3等）不代表任何东西）：

0 => array(
   0 => 1
   1 => 3
),
1 => array(
   0 => 3
   1 => 5
),
2 => array(
   0 => 3
   1 => 7
),
3 => array(
   0 => 3
   1 => 9
),
4 => array(
   0 => 1
   1 => 10
),
5 => array(
   0 => 10
   1 => 15
)

以下是其编码的数据结构的图形表示：

enter image description here

并且以代码格式（虽然我可以从以后生成HTML列表的数组结构的任何更好的想法将被赞赏！）：

0 => array
   0 => 1
   1 => array
      0 => 3
      1 => array
         0 => 5
      2 => array
         0 => 7
      3 => array
         0 => 9
   2 => array
      0 => 10
      1 => array
         0 => 15

使用此数组中的信息，我想生成一个树，然后我可以使用它在html页面中构建菜单。如何仅使用我的父子关系数组来做到这一点？

我知道有很多类似的算法可用于堆栈溢出，但没有一个适用于多个根或我正在使用的特定数组输入结构。

Answer 1

OP在评论中声明这将用于构建菜单系统，因此我编写了一些代码，将数组数组转换为更易于理解的数据结构，构建嵌套列表（适合用作菜单）），并使用来自第二个$content数组的数据填充列表项。实际上，$content中的数据可以是一组链接或任何需要的链接。

# input array
$array = array(
0 => array(
   0 => 1,
   1 => 3
),
1 => array(
   0 => 3,
   1 => 5
),
2 => array(
   0 => 3,
   1 => 7
),
3 => array(
   0 => 3,
   1 => 9
),
4 => array(
   0 => 1,
   1 => 10
),
5 => array(
   0 => 10,
   1 => 15
));

# associative array of node IDs and the node contents
# obviously for a menu, the node contents will probably be links
$content = array(
  1 => 'ape',
  3 => 'bear',
  5 => 'cow',
  7 => 'dog',
  9 => 'elephant',
  10 => 'frog',
  15 => 'giraffe'
);

$tree = [];

# simplify the parent-child 
foreach (array_values($array) as $a) {
  $tree[ $a[0] ][ $a[1] ] = 'value';
}

$roots = get_root($array);

# start our initial list...    
$str = '<ul>';
foreach (array_keys($roots) as $r) {
  $str .= build_tree( $tree, $content, $r );
}
$str .= "</ul>";
echo $str;

/**
 * build_tree($tree, $content, $n)
 * 
 * builds an html representation of a tree using $tree, a data structure
 * containing parent-child relationships, $content, the content of each
 * node of the tree, and $n, the current node in the tree. Calls itself
 * recursively when it encounters a subtree to be built
 *
 * @param array $tree 
 * @param array $content - assoc array of 
 * @param string $n - current node in the tree
 * @return string $html representing the tree
 */
function build_tree($tree, $content, $n) {
  $html = "<li>node id: $n; ".$content[$n]."</li>";
  # does $n exist in $tree -- i.e. does it have a child?
  if ( isset($tree[$n]) ) {
    # if so, start a new nested list
    $html .= '<li><ul>';
    # for each of the children of $n, our parent node,
    # run the build_tree code to create the html
    foreach (array_keys($tree[$n]) as $node) {
      $html .= build_tree($tree, $content, $node);
    }
    $html .= '</ul></li>';
  }
  return $html;
}

/**
 * get_root ( $input )
 *
 * input array format:
 * 0 => [ 0 => parent_node_id, 1 => child_node_id ],
 * 1 => [ 0 => parent_node_id2, 1 => child_node_id2 ],;
 *
 * takes an associative array of parent-child relationships
 * and makes two arrays, one containing all the parent nodes,
 * and one containing the child nodes. The root nodes are
 * those that appear in the parent node array but not the
 * child node array.
 *
 * @param array $input 
 * @return array $r - assoc arr. with root nodes as keys
 */
function get_root ($input) {
  $p = [];
  $c = [];
  $r = [];
  foreach ($input as $k => $v) {
    $p[ $v[0] ] = 1; # parent node
    $c[ $v[1] ] = 1; # child node
  }
  # find the array items in $p that aren't in $c
  foreach ($p as $k => $v) {
    if (! isset($c[$k]) ) {
      $r[$k] = 1;
    }
  }
  return $r;
}

上述代码（test it using this online demo）的结果：

节点ID：1;内容：猿
- 节点ID：3;内容：承担
- - 节点ID：5;内容：牛
  - 节点ID：7;内容：狗
  - 节点ID：9;内容：elephant
- 节点ID：10;内容：青蛙
- - 节点ID：15;内容：长颈鹿

原始HTML（通过HTML整理）：

<ul>
    <li>Node ID: 1; content: ape</li>
    <li>
      <ul>
        <li>Node ID: 3; content: bear</li>
        <li>
          <ul>
            <li>Node ID: 5; content: cow</li>
            <li>Node ID: 7; content: dog</li>
            <li>Node ID: 9; content: elephant</li>
          </ul>
        </li>
        <li>Node ID: 10; content: frog</li>
        <li>
          <ul>
            <li>Node ID: 15; content: giraffe</li>
          </ul>
        </li>
      </ul>
    </li>
</ul>

Answer 2

我的贡献。数组中只有三种元素：

PARENT的元素
PARENT和CHILD的元素
CHILD的元素

根据这三条规则，您可以构建一个菜单：

循环所有元素并按编号存储父母和子女。

result: 3 parents: 1, 3 and 10.
        6 children: 3, 5, 7, 9, 10 and 15.

现在我们需要过滤这些结果：

2a：一个孤独的孩子是孩子中的一个元素，而不是父母
```
       result **real children**: 5, 7, 9, and 15 have no child of their own
```
2b：通过减少所有孩子的LONLY CHILDREN来获得PARENT / CHILD组合
```
       result **parent/child**: 3 and 10 have a parent and child(ren)
```
2c：通过从PARENT中减去PARENT / CHILD获得总体父母
```
       result: **real parent** is 1
```
建立一个菜单，从真正的孩子开始，将他们添加到他们的正确父母，并将其添加到整体父母。

在代码中......

$arr=array(array(1,3),array(3,5),array(3,7),array(3,9),array(1,10),array(10,15));
$menu=array(1=>'menu 1',3=>'menu 3',5=>'menu 5',7=>'menu 7',9=>'menu 9',10=>'menu 10',15=>'menu 15');


  //1. loop array and store parents and children
foreach($arr as $k=>$v){
    $P[$v[0]]=$v[0];
    $PC[$v[1]]=$v[0];
    }
  //2a: filter out the real children
$C = array_diff_key($PC,$P);
  //2b: get the parent_child combinations 
$PC=array_diff_key($PC,$C);
  //3: Get the real parent 
$P=array_diff_key($P,$PC);

 //Sorting the arrays is only needed if the starting array is not ordered
ksort($P);
ksort($PC);
ksort($C);

  //3: Building a menu
  // Create LONELY CHILDS
foreach($C as $k=>$v){
    if(!isset($MC[$v])){$MC[$v]=array();}
    $MC[$v][]='<li>'.$menu[$k].'</li>';
    }

  // Build the PARENT-CHILD menu by adding the CHILDREN to their rightfull parents
foreach($PC as $k=>$v){
    if(!isset($MPC[$v])){$MPC[$v]=array();}
    // $MPC[$v][]='<ul><li>'.$menu[$k].'</li><ul>'.implode('',$MC[$k]).'</ul></ul>'; //(OLD) 
$MPC[$v][]='<ul><li>'.$menu[$k].'<ul>'.implode('',$MC[$k]).'</ul></li></ul>';  //**NEW**
}

  // Create the REAL PARENT
foreach($P as $k=>$v){
    if(!isset($MP[$v])){$MP[$v]=array();}
    $MP[$v][]='<ul><li>'.$menu[$k].implode('',$MPC[$k]).'</li></ul>';
    }

  //CREATE FINAL MENU
$menu=array();
foreach($MP as $k=>$v){
    $menu[]=implode('',$v);
    }
//$menu='<ul>'.implode('',$menu).'</ul>'; //(OLD)
$menu=implode('',$menu);  //**NEW**

echo $menu;

上述结果：

菜单1
- 菜单3
  - menu 5
  - menu 7
  - menu 9
- 菜单10
  - menu 15

编辑更改了两行以创建有效的HTML

和new fiddle

从一组父子关系创建树结构

2 个答案: