Python 以迭代方式逐级打印二叉树的级别

我希望逐级迭代地打印二叉树，而不使用出列或python列表以外的任何其他数据结构。我在网上查过，大多数人都是用上面提到的方法做的

如果我有一棵树：

    41
   /  \
  7   53
 / \  /
1  19 47

我希望它像这样打印：

41

7
53

1
19
47

这是我拍摄的照片，但它没有打印出bst中的所有值：

def levelorder(self):

        current = self._root
        current_left = current_right = self._root
        a = [current._value]

        while current_left is not None and current_right is not None:

            current_left = current_left._left
            current_right = current_right._right

            if current_left is not None:
                a.append(current_left._value)

            if current_right is not None:
                a.append(current_right._value)

        return a

这就是它的输出：

[41, 7, 53, 1]

你知道我的代码有什么问题吗？我该如何解决这个问题

树类：

class _BSTNode:

    def __init__(self, value):

        self._value = copy.deepcopy(value)
        self._left = None
        self._right = None
        self._height = 1
        return

class BST:

    def __init__(self):

        self._root = None
        self._count = 0
        self.comparisons = 0
        return

    def levelorder(self):


        levels = [[self._root]]

        while levels[-1]:

            nextlevel = []
            for node in levels[-1]:
                nextlevel.extend([node for node in (node._left, node._right) if node])

            levels.append(nextlevel)
        return levels[:-1]

我的主要部分是：

b = BST()
b.insert(41)
b.insert(7)
b.insert(53)
b.insert(1)
b.insert(19)
b.insert(47)

print (b.levelorder())

---

没有测试，因为我没有您的

树

类，但我希望总体思路适用：

def levelorder(tree):
    levels = [ [tree.root] ]
    while levels [-1]:
        nextLevel = []
        for node in levels [-1]:
            nextLevel.extend ( [node for node in (node.left, node.right) if node] )
        levels.append (nextLevel)
    return levels # or maybe levels [:-1]

---

完整的工作示例：

#! /usr/bin/python3

class Node:
    def __init__(self, payload, left = None, right = None):
        self.payload = payload
        self.left = left
        self.right = right

    def __repr__(self):
        return self.payload

class Tree:
    def __init__(self, root):
        self.root = root

    def levels(self):
        levels = [[self.root]]
        while levels[-1]:
            nextLevel = []
            for node in levels[-1]:
                nextLevel.extend([node for node in (node.left, node.right) if node])
            levels.append(nextLevel)
        return levels[:-1]

t = Tree(Node('41', Node('7', Node('1'), Node('19')), Node('53', Node('47'))))

print(t.levels())

---

---

输出是

[[41]，[7,53]，[1,19,47]]

这似乎已经得到了回答@Lawrence标题表明正在寻找迭代解决方案。递归深度迭代：）寻找广度优先搜索算法可能重复如果我发布我的树类，你能编辑上面的解决方案吗？我在实现上仍然有一些问题。你的例子帮助我理解了它，但我的例子仍然返回了一个完整的列表，等等。。我已将我的树类添加到原始问题中。知道我还做错了什么吗？@Kalvin94我的代码还返回了

节点

对象的列表，只是我实现了

\uuuu repr\uu

。获取最终输出，访问每个成员的

\u值

，即可设置。类似于

\n\n.join（'\n.join（node.\u值表示级别中的节点）的内容，用于树中的级别。级别（））