python 树的添加节点 广度和深度遍历

功能：给树添加结点
思想：用广度遍历去做
queue = [0]

广度优先，根节点是0的 ，0添加到队列里面
第一次取出0，判断有没有左和右，添加1和2
第二次取出1，添加3和4
第三次取出2，添加5和6
第四次取出3，添加7个8
第五次取出4，添加9

class Node:
        def __init__(self,elem):
                #结点数据
                self.elem= elem
                #左子树和右子树 
                self.lchild = None
                self.rchild = None


#二叉树的实现
class my_tree:
        #初始化空树
        def __init__(self):
                self.root = None

        #树添加元素，广度遍历+队列 
        def add(self,item):
                #创建一个新节点
                node = Node(item)
                #特殊情况，树没有节点 就添加节点
                if self.root is None:
                        self.root = node
                        return
                else:
                        #队列的方式实现 ,队列最开始存根
                        queue = [self.root]
                        #循环处理队列，直到将新结点添加进树为止
                        while queue:
                                #从头取 第一次取的是根节点
                                cur_node = queue.pop(0)
                                # 判断取出的节点有没有左或者右的值 左节点是空，则添加新结点
                                if cur_node.lchild is None:
                                        cur_node.lchild = node
                                        return
                                else:
                                        #左节点不是空，则将左节点添加队列 
                                        queue.append(cur_node.lchild)

                                if cur_node.rchild is None:
                                        cur_node.rchild = node
                                        return
                                else:
                                        queue.append((cur_node.rchild))


#广度遍历
        def tree_travle(self):
                if self.root is None:
                        return
                else:
                        #队列先存根节点
                        queue = [self.root]
                        while queue:
                                #从头取 第一次取的是根节点
                                cur_node = queue.pop(0)
                                print(cur_node.elem,end=' ')
                                #当前打印完的节点还有子节点     
                                if cur_node.lchild is not None:
                                        queue.append(cur_node.lchild)

                                if cur_node.rchild is not None:
                                        queue.append(cur_node.rchild)


#深度遍历  思想是递归 
#先序 根左右 
        def xian(self,root):
                if root == None:
                        return
                else:
                        print(root.elem,end=' ')
                        #递归
                        self.xian(root.lchild)
                        self.xian(root.rchild)


#中序 左根右
        def zhong(self,root):
                if root == None:
                        return

                else:
                        self.zhong(root.lchild)
                        print(root.elem,end=' ')
                        self.zhong(root.rchild)


#后序 左右根
        def hou(self,root):
                if root == None:
                        return

                else:
                        self.hou(root.lchild)
                        self.hou(root.rchild)
                        print(root.elem,end=' ')





if __name__ == '__main__':
        tree = my_tree()
        tree.add(0)
        tree.add(1)
        tree.add(2)
        tree.add(3)
        tree.add(4)
        tree.add(5)
        tree.add(6)
        tree.add(7)
        tree.add(8)
        tree.add(9)
        tree.tree_travle()
         # 广度
        print('')
        # 先序
        tree.xian(tree.root)
        print('')
        # 中序
        tree.zhong(tree.root)
        print('')
        # 后序
        tree.hou(tree.root)