Python BST（二叉搜索树）反向级顺序遍历isn'；I don’我没有给我正确的答案/结果

我真的需要你帮我做这个关于二叉搜索树的练习。我必须颠倒从下到上，从左到右的遍历顺序。以下是练习：

给定一个BST，编写一个返回值列表的函数。位于树最后一个深度的元素将首先出现在输出列表中。上一个深度级别的元素将出现在下一个，一直到根。相同深度的元素将从最小到最大显示在列表中

按顺序排列的元素（树节点）#返回一个列表

例如，如果我们使用按以下顺序插入的值创建BST，则2、1、3、0将返回此列表[0、1、3、2]

如果你不明白，我会这样解释：

这应该返回0，然后是1，然后是3，最后是2（根）

这是练习中给出的模块（它包含二进制搜索树代码，PS：必须使用此模块）：

这给了我一个错误：

列表不同：[2,1]！=[1,2]

期望值：[2,1]

实际：[1,2]

---

只需使用队列创建一个简单的前序遍历

从队列导入队列
def预订单（根）：
ans=[]
q=队列（）
q、 放（根）
而不是q.empty（）：
温度=[]
n=q.qsize（）
而n：
x=q.get（）
n-=1
临时附加（x.data）
如果x.left：
q、 放置（x左）
如果x.right：
q、 放（x右）
ans.append（临时）
打印（ans[：-1]）#打印[[1]、[2]、[3,5]、[4]]作为您的示例

我（终于）解决了这个问题，在尝试了5个小时不同的解决方案后，我返回到这个解决方案并更正了它。这是正确的代码：

import bst

def preorder(root, level, dict):
    
        # base case: empty tree
        if root is None:
            return
        
        # insert current node and its level into the dict
        dict.setdefault(level, []).append(root.data)
        
        # recur for left and right subtree by increasing level by 1
        if root.left is not None:
            preorder(root.left, level + 1, dict)
        if root.right is not None:    
            preorder(root.right , level + 1, dict)
        
        # Recursive function to do reverse level order traversal of given binary tree
def tree_levels(tree):
        list = []
        # create an empty dict to store nodes between given levels
        dict = {}
        
        # traverse the tree and insert its nodes into the dict
        # corresponding to the their level
        preorder(tree, 0, dict)
        
        # iterate through the dict in reverse order and
        # print all nodes present in very level
        for i in range(len(dict)-1,-1,-1):
            list += dict[i]
        return list

---

我希望我可以，但不，我仅限于使用“bst”模块+我必须将它们放在一个列表中，而不是打印它们，而且我也不能将多个列表放在一个列表中，因此我使用此方法删除括号：最新=[I[0]for I in list]return newestOh，您应该添加使用

bst

模块是必须的

class TreeNode(object):
    """A tree node with two children trees"""

    def __init__(self, data, parent=None, left=None, right=None):
        self.data = data
        self.parent = parent
        self.left = left
        self.right = right

    def search(self, value):
        """Search in a BST"""
        if self.data is None:
            return None

        if self.data == value:
            return self

        if value < self.data:
            if self.left is None:
                return None
            return self.left.search(value)

        else:
            if self.right is None:
                return None
            return self.right.search(value)

    def insert(self, value):
        """insert a node in a BST"""
        if self.data is None:
            self.data = value
            return

        if value < self.data:
            if self.left is None:
                self.left = TreeNode(value, self)
            else:
                self.left.insert(value)

        else:
            if self.right is None:
                self.right = TreeNode(value, self)
            else:
                self.right.insert(value)

import bst

def preorder(root, level, dict):

    # base case: empty tree
    if root is None:
        return
    
    # insert current node and its level into the dict
    dict.setdefault(level, []).append(root.data)
    
    # recur for left and right subtree by increasing level by 1
    if root.left is not None:
        preorder(root.left,level + 1, dict)
    if root.right is not None:    
        preorder(root.right,level + 1, dict)
    
    
    # Recursive function to do reverse level order traversal of given binary tree
def tree_levels(tree):
    list = []
    # create an empty dict to store nodes between given levels
    dict = {}
    
    # traverse the tree and insert its nodes into the dict
    # corresponding to the their level
    preorder(tree, 0, dict)
    
    # iterate through the dict in reverse order and
    # print all nodes present in very level
    for i in range(0,len(dict)):
        list.append(dict[i])
    newest = [i[0] for i in list]
    return newest
root = TreeNode(4)
root.insert(5)
root.insert(3)
root.insert(2)
root.insert(1)
tree_levels(root)

import bst

def preorder(root, level, dict):
    
        # base case: empty tree
        if root is None:
            return
        
        # insert current node and its level into the dict
        dict.setdefault(level, []).append(root.data)
        
        # recur for left and right subtree by increasing level by 1
        if root.left is not None:
            preorder(root.left, level + 1, dict)
        if root.right is not None:    
            preorder(root.right , level + 1, dict)
        
        # Recursive function to do reverse level order traversal of given binary tree
def tree_levels(tree):
        list = []
        # create an empty dict to store nodes between given levels
        dict = {}
        
        # traverse the tree and insert its nodes into the dict
        # corresponding to the their level
        preorder(tree, 0, dict)
        
        # iterate through the dict in reverse order and
        # print all nodes present in very level
        for i in range(len(dict)-1,-1,-1):
            list += dict[i]
        return list