Python中的二叉树级顺序遍历

给定以下树：

我应该从左到右返回树的级别顺序遍历： 因此，上面的示例将输出一个列表列表：

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

我编写了下面的代码，idea将节点值及其深度递归地存储在队列中，然后迭代队列元组，如果没有更多具有相同深度的节点，则将其放入中间列表O，并将O追加到输出和空O，依此类推。但是我的代码超时了，有什么帮助吗

import queue

class Solution:
    def levelOrder(self, root: TreeNode) -> List[List[int]]:
        def helper(root,res,level):
            if not root:
                return res
            l=level+1
            res.put((root.val,level))
            helper(root.left,res,l)
            helper(root.right,res,l)

        res=queue.Queue()
        helper(root,res,0)

        d=1
        output=[]
        node,depth=res.get()
        output.append([node])
        while res:
            o=[]
            node,depth=res.get()
            while d ==depth:
                o.append(node)
                node,depth=res.get()
            else:
                d+=1
            output.append(o)    
            
        return output

---

下面是我的代码，用于宽度优先搜索（BFS）迭代实现，在最终输出的每个级别都有节点，它们位于一个列表中：

class TreeNode:
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None

class Solution:
    def BFS(self, root) -> int:
        level=1
        current=(root, level)
        s=set()
        result=[]
        Q = [current]
        while Q:
            current=Q.pop()
            level=current[1]
            if current[0] not in s:
                result.append([current[0].val, level])
                s.add(current[0])
            if current[0].left:
                Q.insert(0,(current[0].left, level+1))
            if current[0].right:
                Q.insert(0,(current[0].right, level+1))
        output=[]
        temp=[]
        level=1
        for val in result:
            if val[1]==level:
                temp.append(val[0])
            elif val[1] > level:
                output.append(temp)
                temp=[val[0]]
                level+=1
        output.append(temp)
        return output

测试：

n1=TreeNode(3)
n2=TreeNode(9)
n3=TreeNode(20)
n4=TreeNode(6)
n5=TreeNode(15)
n6=TreeNode(7)

n1.left=n2
n1.right=n3
n2.left=n4
n3.left=n5
n3.right=n6

sol1=Solution()
print(sol1.BFS(n1))
[[3], [9, 20], [6, 15, 7]]

---

您可以使用以下逻辑打印BFS中的节点。 如果还需要，可以修改该方法以返回列表

def levelOrder(root):
qroot = []
print(root.info,end=' ')
if root.left:
    qroot.append(root.left)
if root.right:
    qroot.append(root.right)

while(qroot):
    tmp = qroot[0]
    if tmp.left:
        qroot.append(tmp.left)
    if tmp.right:
        qroot.append(tmp.right)

    print (tmp.info,end=' ')
    qroot.pop(0)

return

---

您可以直接将值附加到新列表中并返回相同的值，而不是打印值。

谢谢您的回答。这个解决方案帮助我解决了leetcode的问题107。根据我的理解，我做了一点修改。有两种方法可以解决这个问题，但我更喜欢使用BFS时尚。此修订版压缩队列中的值和级别。与仅打印树中每个节点的值相比，它提供了更大的灵活性，如其他教程所提供的

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def levelOrderBottom(self, root: TreeNode) -> List[List[int]]: 
        
        if root is None:
            return None
        
        level = 1
        q = []
        q.append((root,level)) # push both node and level.
        save = []
        
        while q:
            cur = q.pop(0)
            cur_node = cur[0]
            cur_level = cur[1]
            # print(cur_node.val)
            # print(cur_level)  
            save.append([cur_node.val, cur_level])
            if cur_node.left:
                q.append((cur_node.left, cur_level+1))
            if cur_node.right:
                q.append((cur_node.right, cur_level+1))
                
        print(save) # once print, you will have the idea about how to reorgnized the required output.
        level = 1
        output = []
        temp = []
        for i in range(len(save)):
            cur = save[i]
            #print(cur)
            if cur[1] == level:
                temp.append(cur[0])    
            if cur[1] != level:
                output.insert(0, temp)
                temp = []
                temp.append(cur[0])
                level = level + 1
            if i == len(save)-1:
                    output.insert(0, temp)
            
        return output

---

请修复代码的格式。如果9有1或2个子项，请给出预期的输出？只是想确定它是一个正确的预排序树遍历，还是您正在寻找的BFS遍历。@san如果9有一个孩子说“6”，那么输出应该是[[3]、[9,20]、[6,15,7]]@ElenaGT，好的，这就是BFS。我刚刚发布了下面的解决方案作为答案。如果有帮助，请随意接受并投票表决。：-）你能澄清一下这是否是为了解决OP最初的预期任务吗？我发现，即使在解决了格式问题（缩进等）之后，这段代码也陷入了一个无休止的循环中。我也不认为它会按照OP要求的顺序来跟踪级别。很抱歉指出这么多，但希望能有所帮助：）