根据二叉树的抽象数据类型的定义使用二叉链表实现一个二叉树。 二叉树的基本功能： 1、二叉树的建立 2、前序遍历二叉树 3、中序遍历二叉树 4、后序遍历二叉树 5、按层序遍历二叉树 6、求二叉树的深度 7、求指定结点到根的路径 8、二叉树的销毁 9、其他：自定义操作 编写测试 main函数测试二叉树的正确性

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

class BinaryTree:
    def __init__(self, root=None):
        if root:
            self.root = Node(root)
        else:
            self.root = None

    def build_tree(self, nodes):
        if not nodes:
            return None
        self.root = Node(nodes[0])
        queue = [self.root]
        i = 1
        while i < len(nodes):
            cur_node = queue.pop(0)
            if not cur_node:
                continue
            cur_node.left = Node(nodes[i]) if nodes[i] is not None else None
            queue.append(cur_node.left)
            i += 1
            if i < len(nodes):
                cur_node.right = Node(nodes[i]) if nodes[i] is not None else None
                queue.append(cur_node.right)
                i += 1

    def preorder_traversal(self, node, result):
        if not node:
            return
        result.append(node.val)
        self.preorder_traversal(node.left, result)
        self.preorder_traversal(node.right, result)

    def inorder_traversal(self, node, result):
        if not node:
            return
        self.inorder_traversal(node.left, result)
        result.append(node.val)
        self.inorder_traversal(node.right, result)

    def postorder_traversal(self, node, result):
        if not node:
            return
        self.postorder_traversal(node.left, result)
        self.postorder_traversal(node.right, result)
        result.append(node.val)

    def level_order_traversal(self, node, result):
        if not node:
            return
        queue = [node]
        while queue:
            cur_node = queue.pop(0)
            result.append(cur_node.val)
            if cur_node.left:
                queue.append(cur_node.left)
            if cur_node.right:
                queue.append(cur_node.right)

    def get_depth(self, node):
        if not node:
            return 0
        left_depth = self.get_depth(node.left)
        right_depth = self.get_depth(node.right)
        return max(left_depth, right_depth) + 1

    def find_path(self, node, target, path):
        if not node:
            return False
        path.append(node.val)
        if node.val == target:
            return True
        if self.find_path(node.left, target, path) or \
           self.find_path(node.right, target, path):
            return True
        path.pop()

    def destroy_tree(self, node):
        if not node:
            return
        self.destroy_tree(node.left)
        self.destroy_tree(node.right)
        node = None

if __name__ == '__main__':
    tree = BinaryTree()
    tree.build_tree([1, 2, 3, None, None, 4, 5])
    result = []
    tree.preorder_traversal(tree.root, result)
    print(result)  # [1, 2, 3, 4, 5]
    result = []
    tree.inorder_traversal(tree.root, result)
    print(result)  # [2, 1, 4, 3, 5]
    result = []
    tree.postorder_traversal(tree.root, result)
    print(result)  # [2, 4, 5, 3, 1]
    result = []
    tree.level_order_traversal(tree.root, result)
    print(result)  # [1, 2, 3, 4, 5]
    print(tree.get_depth(tree.root))  # 3
    path = []
    tree.find_path(tree.root, 4, path)
    print(path)  # [1, 2, 4]
    tree.destroy_tree(tree.root)
    print(tree.root)  # None
``