二叉树获取每一层的所有节点

Question

我正在尝试解决以下问题，假设我有这个二叉树......

       3
      / \
     9  20
       /  \
      15   7

然后我需要获取每个级别的所有节点，所以我的结果将是......

[[3],[9,20],[15,7]]

我相信我正在接近解决方案，但我不确定我哪里出错了，如果有人可以帮助我解决我的解决方案，那会很棒，如果我走错了路，请告诉我。

我的第一步是使用以下 function 获取树的深度...

def get_depth(self, root):
    if root.left == None and root.right == None:
        return 1
    return max(self.get_depth(root.left), self.get_depth(root.right)) + 1

深度为3 。

接下来，我打电话给 function，旨在给我预期的结果......

def levelOrder(self, root):
    depth = self.get_depth(root)
    return self.find_comb(root, [[]]*depth, 0)

def find_comb(self, root, result, level):
    if root is None:
        return None
    self.find_comb(root.left, result, level+1)
    self.find_comb(root.right, result, level+1)
    result[level].append(root.val)
    return result

我的思考过程是，我将通过树进行递归，并且level参数将跟踪我所在的当前级别。 然后我会 append 所有root.val在那个级别上到那个索引的结果。

所以假设我在1级（我们从 0 开始），那么1级的节点是9和20 。 所以结果看起来像[[], [9, 20], [], []] ，它会为树的每个级别执行此操作。 我希望我的逻辑很清楚。 相反，我得到的结果是......

[[9, 15, 7, 20, 3], [9, 15, 7, 20, 3], [9, 15, 7, 20, 3]]

Answer 1

您实际上不需要找到树的深度。 您只需遍历树，同时保持level不变，就可以说是level可变。 并将您的值插入listOfLists[level] 。 当然，您必须处理IndexError: list index out of range 。 这是一个简单的实现：

def levelTraversal(root, level):
    if root is None:
        return

    if level >= len(listOfLists):
        list = []
        listOfLists.append(list)
    listOfLists[level].append(root.v)
    levelTraversal(root.l, level+1)
    levelTraversal(root.r, level+1)

像这样调用它： levelTraversal(rootNode, 0)

对于您的树，结果为： [[3], [9, 20], [15, 7]]

Answer 2

我不认识Phyton，但您可能想看看Phyton上的BFS实现。

https://www.geeksforgeeks.org/breadth-first-traversal-for-a-graph/

Answer 3

@Schidu Luca 的回答几乎没有改进和变化

问题在于它的实现方式，尽管我们可以检索树的哪个级别，但子节点会丢失哪个父节点。

添加映射子 -> 父

nodes = []

def traverse(root, level, parent):
    if not root:
        return
    if level >= len(nodes):
        nodes_level = []
        nodes.append(nodes_level)
    parent_key = parent and parent.value or None
    nodes[level].append({root.value: parent_key})
    traverse(root.left, level + 1, root)
    traverse(root.right, level + 1, root)


traverse(self.root, 0, None)
return nodes

映射级别 -> 父级 -> 子级

nodes = {}
def traverse_mapped(root, level, parent):
    if not root:
        return
    if level >= len(nodes):
        nodes_level = {}
        nodes[level] = nodes_level
    parent_key = parent and parent.value or None
    if parent_key in nodes[level]:
        nodes[level][parent_key].append(root.value)
    else:
        nodes[level][parent_key] = [root.value]
    traverse_mapped(root.left, level + 1, root)
    traverse_mapped(root.right, level + 1, root)

traverse_mapped(self.root, 0, None)
return nodes