二叉树三种遍历python

class Node(object):
    def __init__(self,item):
        self.elem=item
        self.lchild=None
        self.rchild=None
class Tree(object):
    def __init__(self):
        self.root=None
    def add(self,item):
        #把添加元素变成节点
        node=Node(item)
        #如果原来的树为空，直接把添加元素作为节点
        if self.root is None:
            self.root=node
            return    #跳出整个add
        queue=[self.root]
        #queue列表为空和None不同
        while queue:
            cur_node=queue.pop(0)
            #当前节点的左节点没有的话直接把add的节点加进去
            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 beeadth_travel(self):
        if self.root is None:
            return
        queue=[self.root]
        while queue:
            cur_node=queue.pop(0)
            print(cur_node.elem)
            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 preorder(self,node):
        if node == None:
            return
        print(node.elem,end=" ")
        self.preorder(node.lchild)
        self.preorder(node.rchild)
    #其他遍历只需要改变print的位置即可。


    def Preorder(self,node):
        if node == None:
            return
        GD=Guide(0,node)
        queue=[GD]
        while queue:
            GD=queue.pop(-1)    #相当于从队尾开始取。从队头取的话就要从队头添加新的操作元素，这样的话要用栈来进行操作。
            if GD.node==None:
                continue
            if GD.ope==1:
                print(GD.node.elem, end=" ")
            else:
                queue.append(Guide(0, GD.node.rchild))
                queue.append(Guide(0, GD.node.lchild))
                queue.append(Guide(1, GD.node))
    def preorder1(self,node):
        if node == None:
            return
        queue=[]
        while queue or node:
            while node:
                print(node.elem,end=" ")
                queue.append(node)
                node=node.lchild
            node=queue.pop(-1)
            node=node.rchild

#后序遍历
    def lastorder(self, node):
        if node == None:
            return
        self.lastorder(node.lchild)
        self.lastorder(node.rchild)
        print(node.elem, end=" ")
    def Lastorder(self,node):
        if node == None:
            return
        GD=Guide(0,node)
        queue=[GD]
        while queue:
            GD=queue.pop(-1)    #相当于从队尾开始取。从队头取的话就要从队头添加新的操作元素，这样的话要用栈来进行操作。
            if GD.node==None:
                continue
            if GD.ope==1:
                print(GD.node.elem, end=" ")
            else:
                queue.append(Guide(1, GD.node))
                queue.append(Guide(0, GD.node.rchild))
                queue.append(Guide(0, GD.node.lchild))

    # 先遍历根节点，再遍历右子树，最后是左子树，这样就可以转化为和先序遍历一个类型了，
    # 最后只把遍历结果逆序输出就OK了。
    def lastorder1(self, node):
        if node == None:
            return
        queue1 = []
        queue2=[]
        while queue1 or node:
            while node:
                queue1.append(node)
                queue2.append(node)
                node = node.rchild   #这个while循环退出后，node为空。
            node=queue1.pop()
            node=node.lchild
        while queue2:
            print(queue2.pop().elem,end=" ")



    #中序遍历
    def inorder(self, node):
        if node == None:
            return
        self.inorder(node.lchild)
        print(node.elem, end=" ")
        self.inorder(node.rchild)
    def Inorder(self,node):
        if node == None:
            return
        GD=Guide(0,node)
        queue=[GD]
        while queue:
            GD=queue.pop(-1)    #相当于从队尾开始取。从队头取的话就要从队头添加新的操作元素，这样的话要用栈来进行操作。
            if GD.node==None:
                continue
            if GD.ope==1:
                print(GD.node.elem, end=" ")
            else:
                queue.append(Guide(0, GD.node.rchild))
                queue.append(Guide(1, GD.node))
                queue.append(Guide(0, GD.node.lchild))
    def inorder1(self, node):
        if node == None:
            return
        queue = []
        while queue or node:
            while node:
                queue.append(node)
                node = node.lchild
            node = queue.pop(-1)
            print(node.elem, end=" ")
            node = node.rchild



class Guide(object):
    def __init__(self,ope,node):
        self.ope=ope
        self.node=node

if __name__ == '__main__':
    tree=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.beeadth_travel()
    tree.lastorder(tree.root)
    print("")
    tree.Lastorder(tree.root)
    print("")
    tree.lastorder1(tree.root)