Python 如何从级别顺序遍历创建二叉树？

给定一个包含

None

值的

level\u顺序

列表，如何根据列表中的

None

值构造二叉树，即

None

节点不能有任何子节点（

left

或

right

值）

从输入导入列表，可选
类节点（）：
def uuu init uuuu（val:int=None，左：可选[Node]=None，右：可选[Node]=None）：
self.val=val
self.left=左
self.right=right
def二叉树（级别顺序：列表，根=无）：->节点：
通过

例如，当

级别顺序

为

[4，-7，-3，无，无，-9，-3，9，-7，-4，无，6，无，-6，-6，无，无，0，6，5，无，无，无，无，-1，-4，无，无，无，-2]

时，树应该是这样的

当

级别的顺序为
[1,2,3,4,5]
时，树应该如下所示

以下代码生成二叉树，但不考虑列表中的
None
值

def二叉树（级别顺序，根=无）：
ls=[]
def insert_值（数据，根）：
newnode=节点（数据）
如果len（ls）！=0:
温度=ls[0]
如果root为None：
root=newnode
elif temp.left为无：
temp.left=newnode
elif temp.right为无：
temp.right=newnode
_=ls.pop（0）
ls.append（newnode）
返回根
对于范围内的i（len（level_order））：
根=插入值（级别顺序[i]，根）
返回根

但是上面的代码会导致以下错误的树
首先，如何从树中获取节点的级别顺序列表？那么，返回树的宽度优先遍历中的每个元素。要从级别顺序列表重建树，我们可以以广度优先的方式遍历树

当我们插入每个元素时，从根开始，将其添加到队列中。然后，在完成添加节点的左、右子节点后，从队列中拖出下一个节点。一旦要添加的元素用完，只需返回根

from typing import List, Optional

class Node():
    def __init__(self, val: int=None, left: Optional['Node']=None, right: Optional['Node']=None):
        self.val = val
        self.left = left
        self.right = right

def binary_tree(level_order: List) -> Node:
    values = iter(level_order)
    root = Node(next(values))
    nodes_to_fill = [root]
    try:
        while True:
            next_node = nodes_to_fill.pop(0)
            new_left = next(values)
            if new_left is not None:
                next_node.left = Node(new_left)
                nodes_to_fill.append(next_node.left)
            new_right = next(values)
            if new_right is not None:
                next_node.right = Node(new_right)
                nodes_to_fill.append(next_node.right)
    except StopIteration:
        return root

这与广度优先搜索使用的机制相同，只是在本例中，我们使用它来构建树，而不是搜索树

为了提高效率，如果树非常大，您可以使用
队列。队列
而不是列表。
首先如何从树中获取节点的级别顺序列表？那么，返回树的宽度优先遍历中的每个元素。要从级别顺序列表重建树，我们可以以广度优先的方式遍历树

当我们插入每个元素时，从根开始，将其添加到队列中。然后，在完成添加节点的左、右子节点后，从队列中拖出下一个节点。一旦要添加的元素用完，只需返回根

from typing import List, Optional

class Node():
    def __init__(self, val: int=None, left: Optional['Node']=None, right: Optional['Node']=None):
        self.val = val
        self.left = left
        self.right = right

def binary_tree(level_order: List) -> Node:
    values = iter(level_order)
    root = Node(next(values))
    nodes_to_fill = [root]
    try:
        while True:
            next_node = nodes_to_fill.pop(0)
            new_left = next(values)
            if new_left is not None:
                next_node.left = Node(new_left)
                nodes_to_fill.append(next_node.left)
            new_right = next(values)
            if new_right is not None:
                next_node.right = Node(new_right)
                nodes_to_fill.append(next_node.right)
    except StopIteration:
        return root

这与广度优先搜索使用的机制相同，只是在本例中，我们使用它来构建树，而不是搜索树

为了提高效率，如果您的树非常大，您可能可以使用
队列。队列
而不是列表。
@cs95为problem@cs95为这个问题添加了我现有的代码，谢谢你解释这个方法。我喜欢以下两个值（
new\u left
和
new\u right
）并根据该值将
节点更新为\u fill
。感谢您对该方法的解释。我喜欢以下两个值（
new\u left
和
new\u right
）并基于该值更新
节点以填充。