二叉树遍历（非递归版）——python

二叉树的遍历分为广度优先遍历和深度优先遍历

广度优先遍历(breadth first traversal)：又称层次遍历，从树的根节点(root)开始，从上到下从从左到右遍历整个树的节点。
深度优先遍历(depth first traversal)：对于一颗二叉树，深度优先遍历是沿着树的深度遍历树的节点，尽可能深的搜索树的分支。深度优先遍历有重要的三种方法。这三种方式常被用于访问树的节点，它们之间的不同在于访问每个节点的次序不同。这三种遍历分别叫做先序遍历（preorder）：根节点->左子树->右子树，中序遍历（inorder）：左子树->根节点->右子树，和后序遍历（postorder）：左子树->右子树->根节点。这三种都是递归方式实现对一整个二叉树遍历的哦。
代码（非递归版）

class TreeNode:
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None
class Trees:    #根据前序和中序列表来重建二叉树
    def reConstructBinaryTree(self, pre, tin):
        # write code here
        if len(pre) == 0:
            return None
        if len(pre) == 1:
            return TreeNode(pre[0])
        else:
            flag = TreeNode(pre[0])
            flag.left = self.reConstructBinaryTree(pre[1:tin.index(pre[0])+1],tin[:tin.index(pre[0])])
            flag.right = self.reConstructBinaryTree(pre[tin.index(pre[0])+1:],tin[tin.index(pre[0])+1:])
        return flag
    #前序遍历
    def preOrder(self, root):
        if root == None:
            return
        stack = []
        result = []
        node = root
        while node or stack:
            while node:
                # 从根节点开始，一直找它的左子树
                result.append(node.val)
                stack.append(node)
                node = node.left
            # while结束表示当前节点node为空，即前一个节点没有左子树了
            node = stack.pop()
            # 开始查看它的右子树
            node = node.right
        return result
    #中序遍历
    def inOrder(self,root):
        if root == None:
            return
        stack = []
        result = []
        node = root
        while node or stack:
            while node:
                #　从根节点开始，一直找到左子树
                stack.append(node)
                node = node.left
            # while结束表示当前节点node为空，即前一个节点没有左子树了
            node = stack.pop()
            result.append(node.val)
            node = node.right
        return result
    #后序遍历
    def postOrder(self, root):
        if root == None:
            return
        stack = []
        result = []
        node = root
        while node or stack:
            while node:
                # 从根节点开始，一直找它的右子树
                result.insert(0,node.val)
                stack.append(node)
                node = node.right
            # while结束表示当前节点node为空，即前一个节点没有右子树了
            node = stack.pop()
            # 开始查看它的左子树
            node = node.left
        return result
    #广度优先遍历(即层次遍历)
    def breadthFirstTravel(self,root):
        if root == None:
            return
        queue = [root]
        result = []
        while queue:
            node = queue.pop(0)
            result.append(node.val)
            if node.left:
                queue.append(node.left)
            if node.right:
                queue.append(node.right)
        return result   
    
pre = [1,2,4,8,5,3,6,7]   
tin = [8,4,2,5,1,6,3,7]
pos = [8,4,5,2,6,7,3,1]

demo = Trees()
Nroot = demo.reConstructBinaryTree(pre,tin)
print(demo.preOrder(Nroot))
print(demo.inOrder(Nroot))
print(demo.postOrder(Nroot))
print(demo.breadthFirstTravel(Nroot))

前序和中序遍历的结构基本相似，前序遍历的顺序是"根左右"，从根节点一直向左找到最左的叶子结点，再依次从下往上路径上结点的右子树。

中序遍历的顺序是“左根右”，从根节点一直向左找到最左的叶子结点，先访问其右子树，再一次沿着路径向上到根节点，之后是根几点的右子树。
后续遍历的顺序是“左右根”，不好遍历，从左节点到右节点是“跳过去的”，换种方法，先把遍历顺序反过来——“根右左”，这种顺序熟悉，就把前序遍历的node.left与node.right交换就可以了，得到的遍历顺序表与后续遍历的顺序表应该是相反的，故可以在列表增加元素的时候反过来或者最后使用list.reverse().
广度优先遍历就是从上往下，从左往右打印，利用队列先入先出，若把同一行的结点放在一起，在里边需要再增加一个临时列表。