二叉树遍历

class TreeNode:
    def __init__(self,x):
        self.value = x
        self.left = None
        self.right = None

class Tree:
    def __init__(self):
        self.queue = [] #用队列存储树的结点
        self.flag = 0   #存树根后flag置为1
        self.root = None
    #建树
    def createTree(self,arr):
        while True:
            if len(arr) == 0:
                return 
            if self.flag == 0:                  #根不存在
                self.root = TreeNode(arr[0])
                self.queue.append(self.root)    #将树根存到队列
                self.flag = 1                   
                arr.pop(0)
            else:
                treeNode = self.queue[0]    #队列中的第一个节点
                if treeNode.left is None:
                    treeNode.left = TreeNode(arr[0])
                    self.queue.append(treeNode.left)
                    arr.pop(0)
                else:
                    treeNode.right = TreeNode(arr[0])
                    self.queue.append(treeNode.right)
                    arr.pop(0)
                    self.queue.pop(0)
    #递归实现前序遍历
    def pre(self,root):
        if root is None:
            return 
        else:
            print(root.value,end=' ')
            self.pre(root.left)
            self.pre(root.right)
    #递归实现中序遍历
    def tin(self,root):
        if root is None:
            return 
        else:
            self.tin(root.left)
            print(root.value,end=' ')
            self.tin(root.right)
    #递归实现后序遍历
    def post(self,root):
        if root is None:
            return 
        else:
            self.post(root.left)
            self.post(root.right)
            print(root.value,end=' ')

    #队栈实现前序遍历(非递归)
    def pre_stack(self,root):
        if root is None:
            return 
        stack = []                      #定义一个栈，存储节点
        while stack or root:
            while root:         
                print(root.value,end=' ')       #从根结点开始一直输出左孩子
                stack.append(root)
                root = root.left
            #该节点不存在左孩子时，该节点出栈，搜索该节点右孩子
            node = stack.pop()
            root = node.right

    #栈实现中序遍历（非递归）
    def tin_stack(self,root):
        if root is None:
            return 
        stack = []
        while stack or root:
            while root:
                stack.append(root)
                root = root.left
            node = stack.pop()
            print(node.value,end=' ')
            root = node.right

    #栈实现后序遍历（非递归）
    # 模拟逆序(根右左)存入Stack2，然后在stack2逆序输出
    # (根右左)与(根左右)类似，入栈stack1前读（根、右），出栈后指针变更再读左
    def post_stack(self,root):
        if root is None:
            return
        stack1 = []
        stack2 = []
        while stack1 or root:
            while root:
                stack2.append(root.value)
                stack1.append(root)
                root = root.right
            node = stack1.pop()
            root = node.left
        print(stack2[::-1])

    #广度优先遍历，层次遍历
    def level(self,root):
        stack = []
        stack.append(root)
        while stack:
            head = stack.pop(0)
            print(head.value,end=' ')
            if head.left:
                stack.append(head.left)
            if head.right:
                stack.append(head.right)

    #获取树的深度(递归)
    def get_depth_digui(self,root):
        if not root:
            return 0
        left = right = 0
        left = self.get_depth_digui(root.left)
        right = self.get_depth_digui(root.right)
        return max(left,right)+1

    #获取树的深度(非递归)
    #利用广度优先遍历
    def get_depth(self,root):
        stack1 = []
        stack2 = []
        stack1.append(root)
        stack2.append(1)
        while stack1:
            head = stack1.pop(0)
            p = stack2.pop(0)
            if head.left:
                stack1.append(head.left)
                stack2.append(p+1)
            if head.right:
                stack2.append(p+1)
                stack1.append(head.right)
        return p

    #已知前序中序重构二叉树
    def reconstruct_tree(pre,tin):
        if not pre and not tin:
            return 
        if set(pre) != set(tin):
            return 
        root = TreeNode(pre[0])
        i = tin.index(pre[0])
        self.reconstruct_tree(pre[1:i+1],tin[:i])
        self.reconstruct_tree(pre[i+1:],tin[i+1:])
        return root

if __name__ == '__main__':
    arr = [0,1,2,3,4,5,6,7,8,9]
    tree = Tree()
    tree.createTree(arr)
    tree.pre(tree.root)
    print()

    tree.tin(tree.root)
    print()

    tree.post(tree.root)
    print()

    tree.pre_stack(tree.root)
    print()

    tree.tin_stack(tree.root)
    print()

    tree.post_stack(tree.root)

    tree.level(tree.root)
    print()

    print(tree.get_depth_digui(tree.root))
    print(tree.get_depth(tree.root))