python 实现二叉树

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

node_list = [
{'data':'A', 'left':'B', 'right':'C', 'is_root':True},
{'data':'B', 'left':'D', 'right':'E', 'is_root':False},
{'data':'D', 'left':None, 'right':None, 'is_root':False},
{'data':'E', 'left':'H', 'right':None, 'is_root':False},
{'data':'H', 'left':None, 'right':None, 'is_root':False},
{'data':'C', 'left':'F', 'right':'G', 'is_root':False},
{'data':'F', 'left':None, 'right':None, 'is_root':False},
{'data':'G', 'left':'I', 'right':'J', 'is_root':False},
{'data':'I', 'left':None, 'right':None, 'is_root':False},
{'data':'J', 'left':None, 'right':None, 'is_root':False},

]

# 其实BinTree的作用就是把每一个结点链接起来

class BinTree(object):
    def __init__(self, root = None):
        self.root = root

# classmethod 修饰符对应的函数不需要实例化，不需要 self 参数，
# 但第一个参数需要是表示自身类的 cls 参数，可以来调用类的属性，类的方法，实例化对象等。

    @classmethod
    def build_from(cls, node_list):
        """
        通过结点信息构造二叉树，。
        第一次遍历构造node结点，第二次遍历，我们给root和孩子赋值。
        最后我们用root初始化这个类，并且返回一个对象
        """
        node_dict = {}   # 字典
        for node_data in node_list:
            data = node_data['data']
            node_dict[data] = BinTreeNode(data)  # 构造了结点
        for node_data in node_list:
            data = node_data['data']
            node = node_dict[data]
            if node_data['is_root']:
                root = node
            # 之前已经把所有的结点都加入到node_dict里面了。
            node.left = node_dict.get(node_data['left'])
            node.right = node_dict.get(node_data['right'])

        return cls(root)


    def preorder_trav(self, subtree):
        # 先序遍历

        if subtree is not None:
            print(subtree.data) # 递归函数里面先处理根
            self.preorder_trav(subtree.left)
            self.preorder_trav(subtree.right)


    def midorder_trav(self, subtree):
        if subtree is not None:
            self.preorder_trav(subtree.left)
            print(subtree.data) # 递归函数里面先处理根
            self.preorder_trav(subtree.right)


    def afterorder_trav(self, subtree):
        if subtree is not None:
            self.preorder_trav(subtree.left)
            self.preorder_trav(subtree.right)
            print(subtree.data) # 递归函数里面先处理根


    # 反转二叉树
    def reverse(self, subtree):
        if subtree is not None:
            subtree.left, subtree.right = subtree.right, subtree.left
            self.reverse(subtree.left)
            self.reverse(subtree.right)






btree = BinTree.build_from(node_list)
print("先序遍历")
btree.preorder_trav(btree.root)
print("中序遍历")
btree.midorder_trav(btree.root)
print("后序遍历")
btree.afterorder_trav(btree.root)

btree.reverse(btree.root)
print("反转后后序遍历")
btree.afterorder_trav(btree.root)