python 数据结构 树的实现

本人菜鸟一枚，如果大佬发现不对，请多指正，谢谢啦！！！

class Node():
    def __init__(self,item):
        self.item=item
        self.lchild=None
        self.rchild=None
        
class Tree():
    def __init__(self):
        self.root=None
    def attend(self,item):
        node=Node(item)
        if self.root==None:
            self.root=node
            return
        queue=[self.root]
        while queue:
            cur=queue.pop(0)
            if cur.lchild is None:
                cur.lchild=node
                return
            else:
                queue.append(cur.lchild)
            if cur.rchild is None:
                cur.rchild=node
                return
            else:
                queue.append(cur.rchild)
    #广度遍历
    def breath_travel(self):
        if self.root is None:
            return
        queue=[self.root]
        while queue:
            cur=queue.pop(0)
            print(cur.item,end='')
            if cur.lchild is not None:
                queue.append(cur.lchild)
            if cur.rchild is not None:
                queue.append(cur.rchild)
    def breath_travel_list(self):
        if self.root==None:
            return
        res=[]
        queue=[self.root]
        while queue:
            node_list=[]
            node_val=[]
            for node in queue:
                node_val.append(node.item)
                if node.lchild is not None:
                    node_list.append(node.lchild)
                if node.rchild is not None:
                    node_list.append(node.rchild)
            res.append(node_val)
            queue=node_list
        return res
    #判断两棵树是否相同
    def is_same(self,t1,t2):
        if not t1 or not t2:
            return True
        return t1.item==t2.item and self.is_same(t1.lchild,t2.lchild) and self.is_same(t1.rchild,t2.rchild)
    
    def is_same_symmetry(self,t1,t2):
        if not t1 or not t2:                
           return True
        return t1.item==t2.item and self.is_same(t1.lchild,t2.rchild) and self.is_same(t1.rchild,t2.lchild)
    #判断树是否对称
    def mid_symmetry(self,t1):
        if t1==None:
            return True
        return self.is_same_symmetry(t1.lchild,t1.rchild)
    #判断树的最大深度
    def max_depth(self,root):
        if root==None:
            return 0
        return max(self.max_depth(root.lchild),self.max_depth(root.rchild))+1
    #前序遍历
    def preorder(self,node):
        l=[]
        if node is None:
            return []
        l.append(node.item)
        l+=self.preorder(node.lchild)
        l+=self.preorder(node.rchild)
        return l
    #中序遍历
    def midorder(self,node):
        l=[]
        if node is None:
            return []
        l+=self.midorder(node.lchild)
        l.append(node.item)
        l+=self.midorder(node.rchild)
        return l
    #后序遍历
    def endorder(self,node):
        l=[]
        if node is None:
            return []
        l+=self.endorder(node.lchild)
        l+=self.endorder(node.rchild)
        l.append(node.item)
        return l
#测试
if __name__=='__main__':
    tree=Tree()
    tree.attend(0)
    tree.attend(1)
    tree.attend(2)
    tree.attend(3)
    tree.attend(4)
    tree.attend(5)
    tree.breath_travel()
    print()
    print(tree.preorder(tree.root))
    print()
    print(tree.midorder(tree.root))
    print()
    print(tree.endorder(tree.root))
    print(tree.breath_travel_list())
    tree1=Tree()
    tree1.attend(0)
    tree1.attend(1)
    tree1.attend(2)
    tree1.attend(3)
    tree1.attend(4)
    tree1.attend(5)
    print(tree1.is_same(tree.root,tree1.root))
    tree2=Tree()
    tree2.attend(0)
    tree2.attend(1)
    tree2.attend(1)
    tree2.attend(2)
    tree2.attend(2)
    tree2.attend(2)
    tree2.attend(2)
    print(tree2.mid_symmetry(tree2.root))
    print(tree2.max_depth(tree2.root))