二叉树非递归遍历

前序遍历：

  前序遍历的规则是根结点-->左子树-->右子树。也就是从根结点开始一直找他的左子树，在左子树里也是根结点-->左子树-->右子树的规则，所以就是一直找根结点的左子结点，直到找不到左子结点，这时候就应该去遍历它的右子树了。

def preOrder(self, root):
    if root == None:
        return
    stack = []
    node = root
    while node or stack:
        while node:
            # 从根节点开始，一直找它的左子树

            print(node.val)  # 先输出根结点

            stack.append(node)
            node = node.left
        # while结束表示当前节点node为空，即前一个节点没有左子树了
        # 也就是左子树到底了
        # 到底之后就得遍历右子树，先得把左子树最底部的结点弹出来，遍历这个结点的右子树
        node = stack.pop()
        # 开始查看它的右子树
        node = node.right

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def preorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        res = []
        stack = [root]
        while stack:
            node = stack.pop()
            if node:
                res.append(node.val)
                stack.append(node.right)
                stack.append(node.left)
        return res

中序遍历：

  中序遍历的规则就是：左子树-->根结点-->右子树。它和前序遍历不同在于，找到左子树的底之后，再从左子树的底开始输出结点，输出之后再去遍历它的右子树。

def inOrder(self,root):
    if root == None:
        return
    stack = []
    node = root
    while node or stack:
        while node:
            #　从根节点开始，一直找到左子树
            stack.append(node)
            node = node.left
        # while结束表示当前节点node为空，即前一个节点没有左子树了
        node = stack.pop()

        print(node.val)  # 输出结点的值

        # 遍历结点的右子树
        node = node.right

后序遍历：

def postOrder(self,root):
    if root == None:
        return
    stack1 = []
    stack2 = []
    node = root
    stack1.append(node)
    while stack1:
    # 这个while循环用户找到后续遍历的逆序，存在stack2中
        node = stack1.pop()
        if node.left:
            stack1.append(node.left)
        if node.right:
            stack1.append(node.right)
        stack2.append(node)
    while stack2:
        print(stack2.pop().val)

它的思路就是说：从顶往下开始，先放在stack1里，保证左子树在右子树下面，这样从stack1出栈的时候放在stack2里的时候左子树在右子树上面了。一个结点出栈stack1的时候，就把它的左子结点，右子结点依次入栈，在进入stack2的时候调整一下顺序。

用从左到右和从上到下的前序遍历，再倒序输出就是从下到上和从左到右的后序遍历。 

class Solution(object):
    def postorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        if root is None:
            return []

        # BFS  注意在栈里左子节点在右子节点下面
        stack, output = [root, ], []
        while stack:
            root = stack.pop()
            output.append(root.val)
            if root.left is not None:
                stack.append(root.left)
            if root.right is not None:
                stack.append(root.right)
                
        return output[::-1]