树的先序遍历，中序遍历，后续遍历（递归和非递归实现）

前序遍历是先访问根节点再访问左子树最后访问右子树（中，左，右）；中序遍历是先访问左子树再访问根节点最后访问右子树（左，中，右）；后序遍历是先访问左子树再访问右子树最后访问根节点（左，右，中）。---------其实就是根节点的访问顺序，看递归程序的print(root.val)位置。

1.前序遍历
递归实现：

 def preOrder(self,root):
    if rooot == None:
        return
    print(root.val)
    self.preOrder(root.left)
    self.preOrder(root.right)

非递归实现跟DFS一样：

def preOrder(self,root):
    if root==None:
        return
    stack=[]
    stack.append(root)
    while stack:
        cur = stack.pop()
        print(cur.val)
        if cur.rchild!=None:
            stack.append(stack.rchild)
        if cur.lchild!= None:
            stack.append(stack.lchild)

2.中序遍历：
递归：

 def preOrder(self,root):
    if rooot == None:
        return
    self.preOrder(root.left)
    print(root.val)
    self.preOrder(root.right)

非递归：
左子树一直往下，并一直压入栈，直到没有左子树，输出最小左子树的根节点，最小左子树的右子树压入栈中

def inOrder(self,root):
    if root == None:
        return
    stack =[]
    cur = root
    stack.append(cur)
    while stack:
        while cur.left:
            cur = cur.left
            stack.append(cur)
        node = stack.pop()
        print(node.val) 
        if node.right:     
            cur = node.right
            stack.append(cur)

3.后序遍历
递归：

def postOrder(self,root):
    if root == None:
        return
    self.postOrder(root.lchild)
    self.postOrder(root.rchild)
    print(root.val)

非递归：
非递归遍历思路如下：
1）申请两个栈s1，s2，然后将头结点压入s1
2）从s1中弹出的结点记为node,并加入到栈s2中，然后把node的左孩子压入s1中，然后把node的右孩子压入s1中(s2的进栈顺序根–>右–>左，所以最后弹出左–>右–>根)
3）不断重复2，直到s1为空
4）从s2弹出结点并打印

def postOrder(self, root):
    if root == None:
        return
    stack1=[root]
    stack2=[]
    while stack1:
        node = stack1.pop()
        stack2.append(node)
        if node.left:
            stack1.append(node.left)
        if node.right:
            stcak1.append(node.right)
    while stack2:
        print(stack2.pop().val)

参考博客