二叉树遍历（添加元素、递归遍历、非递归遍历、morris遍历)

添加元素、广度遍历、深度递归遍历（递归、非递归）、morris遍历

class Node():
    def __init__(self,item):
        self.elem=item
        self.lchild=None
        self.rchild=None
class Tree():
    def __init__(self):
        self.root=None
    def add(self,item):
        node=Node(item)
        if self.root is None:
            self.root=node
            return
        queue=[]
        queue.append(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 breadth_travel(self):
        #广度遍历
        if self.root is None:
            return
        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 preorder(self,node):
        #先序
        if node==None:
            return
        print(node.elem,end=" ")
        self.preorder(node.lchild)
        self.preorder(node.rchild)

    def midorder(self,node):
        #中序
        if node==None:
            return
        self.midorder(node.lchild)
        print(node.elem, end=" ")
        self.midorder(node.rchild)

    def lastorder(self,node):
        #后序
        if node==None:
            return
        self.lastorder(node.lchild)
        self.lastorder(node.rchild)
        print(node.elem, end=" ")
    def preorderUnrecur(self,head):  #非递归版先序遍历
        if head!= None:
            stack=[]
            stack.append(head)
            while stack:
                head=stack.pop()
                print(head.elem,end=" ")
                if head.rchild:
                    stack.append(head.rchild)
                if head.lchild:
                    stack.append(head.lchild)
    def inorderUnrecur(self,head):      #非递归版中序遍历
        if head!=None:
            stack=[]
            while stack or head!=None:
                if head!=None:
                    stack.append(head)
                    head=head.lchild
                else:
                    head=stack.pop()
                    print(head.elem,end=" ")
                    head=head.rchild
    def posorderUnrecur(self,head):    #非递归版后序遍历
        if head!=None:
            stack1=[]
            stack2=[]
            stack1.append(head)
            while stack1:
                head=stack1.pop()
                stack2.append(head)
                if head.lchild:
                    stack1.append(head.lchild)
                if head.rchild:
                    stack1.append(head.rchild)
            while stack2:
                print(stack2.pop().elem,end=" ")
    def morrispre(self,head):    #morris先序遍历
        if head==None:
            return
        cur1=head
        cur2=None
        while cur1!=None:
            cur2=cur1.lchild
            if cur2!=None:  #有左子树,找左子树最右节点
                while cur2.rchild!=None and cur2.rchild!=cur1:
                    cur2=cur2.rchild
                if cur2.rchild==None: #第一次经过头节点，打印
                    cur2.rchild=cur1
                    print(cur1.elem,end=" ")
                    cur1=cur1.lchild
                    continue
                else:                 #第二次经过头节点，不打印
                    cur2.rchild=None
            else:
                print(cur1.elem,end=" ")
            cur1=cur1.rchild
    def morrisin(self,head):            #morris中序遍历
        if head==None:
            return
        cur1=head
        cur2=None
        while cur1!=None:
            cur2=cur1.lchild
            if cur2!=None:  #有左子树,找左子树最右节点
                while cur2.rchild!=None and cur2.rchild!=cur1:
                    cur2=cur2.rchild
                if cur2.rchild==None: #第一次经过头节点，不打印
                    cur2.rchild=cur1
                    cur1=cur1.lchild
                    continue
                else:                 #第二次经过头节点，打印
                    cur2.rchild=None
            print(cur1.elem,end=" ")
            cur1=cur1.rchild
    def morrispos(self,head):             #morris后序遍历
        if head==None:
            return
        cur1=head
        cur2=None
        while cur1!=None:
            cur2=cur1.lchild
            if cur2!=None:  #有左子树,找左子树最右节点
                while cur2.rchild!=None and cur2.rchild!=cur1:
                    cur2=cur2.rchild
                if cur2.rchild==None: #第一次经过头节点
                    cur2.rchild=cur1
                    cur1=cur1.lchild
                    continue
                else:                 #第二次经过头节点，逆序打印左子树的右边界
                    cur2.rchild=None
                    self.printedge(cur1.lchild)
            cur1=cur1.rchild
        self.printedge(head)          #最后逆序打印整个树的右边界
    def printedge(self,head):
        tail=self.reveredge(head)
        cur=tail
        while cur!=None:
            print(cur.elem,end=" ")
            cur=cur.rchild
        self.reveredge(tail)
    def reveredge(self,fromm):
        pre=None
        nexxt=None
        while fromm!=None:
            nexxt=fromm.rchild
            fromm.rchild=pre
            pre=fromm
            fromm=nexxt
        return pre

tre=Tree()
tre.add(0)
tre.add(1)
tre.add(2)
tre.add(3)
tre.add(4)
tre.add(5)
tre.add(6)
tre.add(7)
tre.add(8)
tre.add(9)
tre.breadth_travel()
print()
tre.preorder(tre.root)
print()
tre.midorder(tre.root)
print()
tre.lastorder(tre.root)
print()
tre.preorderUnrecur(tre.root)
print()
tre.inorderUnrecur(tre.root)
print()
tre.posorderUnrecur(tre.root)
print()
tre.morrispre(tre.root)
print()
tre.morrisin(tre.root)
print()
tre.morrispos(tre.root)