使用递归存储在 JSON 中的二叉搜索树遍历

Question

我正在尝试编写一个函数来遍历树并将值存储在字典中。 我正在使用字典，因为我希望以 JSON 格式保存树的结构。 但是返回只给了我树的第一层。 我已经使用插入函数插入了节点。 这是我试图理解树中的递归。

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

def __str__(self):
    return str(self.data)

class BinarySearchTree:
    def __init__(self):
        self.root = None

# Return the BST object in dictionary format
def __str__(self):
    return str(self.__dict__)

def traverse(self, current_node):
    tree = {'root': current_node.data}
    print(tree)
    if current_node.left is not None:
        tree.update({'left': current_node.left.data})
        print(tree)
        self.traverse(current_node.left)
    if current_node.right is not None:
        tree.update({'right': current_node.right.data})
        print(tree)
        self.traverse(current_node.right)
    return tree

My Output:
     __10_____           
    /         \          
   _5_       20_________ 
  /   \     /           \
 _3   7    15    ______73
/  \ /    /     /        
1  4 6   12    25___     
 \                  \    
 2                 30_   
                  /   \  
                 27  35  
{'root': 10}
{'root': 10, 'left': 5}
{'root': 5}
{'root': 5, 'left': 3}
{'root': 3}
{'root': 3, 'left': 1}
{'root': 1}
{'root': 1, 'right': 2}
{'root': 2}
{'root': 3, 'left': 1, 'right': 4}
{'root': 4}
{'root': 5, 'left': 3, 'right': 7}
{'root': 7}
{'root': 7, 'left': 6}
{'root': 6}
{'root': 10, 'left': 5, 'right': 20}
{'root': 20}
{'root': 20, 'left': 15}
{'root': 15}
{'root': 15, 'left': 12}
{'root': 12}
{'root': 20, 'left': 15, 'right': 73}
{'root': 73}
{'root': 73, 'left': 25}
{'root': 25}
{'root': 25, 'right': 30}
{'root': 30}
{'root': 30, 'left': 27}
{'root': 27}
{'root': 30, 'left': 27, 'right': 35}
{'root': 35}
{'root': 10, 'left': 5, 'right': 20}

进程以退出代码 0 结束

Answer 1

dict 中right left不应该有数据作为值，而是字典。 因此，将递归调用的结果分配给这些键。

我也会给最后一个参数一个默认值，所以主调用者不必指定它。

    def traverse(self, current_node=None):
        if not current_node:
            current_node = self.root
        tree = {'data': current_node.data}
        if current_node.left:
            tree.update({'left': self.traverse(current_node.left)})
        if current_node.right:
            tree.update({'right': self.traverse(current_node.right)})
        return tree