树创建 Python 解决方案

Question

我有一个字符串列表

data = ['1', '8TUV', '0', '0', '4GHI', '6MNO', '8TUV', '5JKL', '8TUV', '6MNO', '5JKL']

预期输出图：

                               1
                           / |  |    \ 
                          8  T   U     V
                         /   |    |      \
                        0    0    0        0
                       /     |     \        \
                      0      0       0       0 
                    // |\  // |\   // |\   // |\
                   4 G H I 4 G H I 4 G H I 4 G H I
             //// ////||||\\\\
           6MNO 6MNO 6MNO 6MNO 
                   

Now 4 will have children [6,M,N,O], G will have children [6,M,N,O], H will have children [6,M,N,O], I will have children [6,M,N,O].

结构是这样的， 数据的第一个元素是根。 第二个元素是第一个元素的子元素。如果第二个元素的长度 > 1，比如长度为 'l'，那么第一个元素将有 l 个子元素。 l[0] .. l[n] 个子元素将第三个元素作为子元素，依此类推。 叶元素应该像 6MNO (data[9])

 6    M     N   O
|||| |||| |||| ||||
5JKL 5JKL 5JKL 5JKL [Leaf elements, since no element exists after 5JKL in data]

data 列表中的每个“i+1”元素都是“i”元素的子元素。如果 i+1 元素的长度 == 0，则 data 的“i”元素有 1 个子元素，但是，如果“i+1”元素的长度大于 1，则“i”元素子元素的数量将等于 i+1 元素的长度。

另一个例子：

这是我的类来表示单个节点的结构。

class Node:
  def __init__(self,c='%',children={}):
    self.c = c #c => character
    self.children = children # 
    }

Node(character='1',
children: {
8: Node(character:'8',children:{}),
T: Node(character:'T',children:{}),
U: Node(character:'U',children:{}),
V: Node(character:'V',children:{})
})

I want (came up with this structure) a tree structure in this way (expected output)

{
  c='1',
  children={
    'T': {
      c = 'T',
      children = {
        c='0',
        children = {
          c = '0',
          children = {
            'G'={},
            'H'={},
            'I'={}
          }
        }
      }
    },
    'U': {
      c = 'U',
      children:{
       .
      .
      }
    },
    'V': {
      c = 'V',
      children:{
      .
      .
      }
    }
  }
}

我知道我需要使用递归和 DFS，但我想不出解决方案。任何真正有用的建议/反馈。

我的逻辑：

root = Node(data[0]) // 1 
def dfs(node,data):
  if not data or len(data) == 0:
    return node.children
  for i in range(1,len(data)):
    node.children[i-1] = dfs(node,data[i:])
  #now current node should be list(node.children.keys())[0] to #list(node.children.keys())[n]
  for k,v in node.children.items():
    node = node.children[k]
# perform call recursive function again. 
dfs(root,data)

Answer 1

几个有趣的点实际上可以让您不必创建自己的 Class 节点，您可以只打印给定元素列表的树形图。

有趣的点->

1.) 一棵树没有循环。因此，如果从根开始遍历，则每个节点都可以访问一次。 （节点标记不需要做）

2.) 每个节点都是一个独立的 d-ary 节点（意味着级别-i 位置-j 的分支因子的唯一限制是元素列表的第 (i+1) 个索引中的元素数

3.) 级联效应 -> 如果第 i 级导致 x_i 个分支，第 i+1 级导致 x_(i+1) 个分支，则次数为一个单元的次数（超过这里一个单元是列表的一个元素，它又是一个字符串/字符）将出现在第 i+2 级是 -> x_0 * x_1 * ...x_(i+1) * sizeOf(unit)

尔格

给定一些输入 ->

data = ['1', '8TUV', '0', '0', '4GHI', '6MNO', '8TUV', '5JKL', '8TUV', '6MNO', '5JKL']

打印 '1' - 1 次

打印 '8TUV' - 1 次（分为 '8'、'T'、'U'、'V'）

打印 '0' - 1 * 4 次

打印 '0' - 1 * 4 * 1 次

打印'4GHI' - 1 * 4 * 1 * 1 次（分成'4'、'G'、'H'、'I'）

打印'6MNO' - 1 * 4 * 1 * 1 * 4 次（分成'6'、'M'、'N'、'0'）

...