leecode144. 94.145. 树的遍历合集：前序、中序、后序，递归法、迭代法

1. 树的前序、中序、后序遍历

这里的前序，中序，后序指的是根节点。
如果是前序，则遍历顺序为 根节点-左节点-右节点
如果是中序，则为 左-根-右
如果是后序，则为 左-右-根

1.1 树的前序遍历

比如对这颗树，前序遍历指先遍历跟节点，那么第一遍历的是F,存储遍历的表记为$[F]$
接下来遍历左节点，B，B也是根节点，加入遍历的列表，然后遍历B的左节点A，A加入，然后遍历A的左节点右节点，都不存在，则返回A的上个节点B，遍历B的右节点，此时为$[F,B,A]$
B的右节点为D，D为根节点，加入，遍历D的左节点，C加入，C没有子节点了，返回上一级D，遍历D的右节点E，加入。E没有子节点了返回上一级D，D继续往上返回到B，B继续网上返回到F，此时存储的表为$[F,B,A,D,C,E]$。
接下来访问F的右节点G，加入遍历的表，然后访问G的子节点，G没有左节点，返回G，访问G的右节点I，加入遍历的表，然后访问I的右节点，不存在，返回I，返回G，返回F。
最后存储的表为$[F,B,A,D,C,E,G,I,H]$

1.2 树的中序遍历

顺序为左节点-根节点-右节点
对于根节点F，存在左节点B，B存在左节点A，A不存在左节点，将A加入遍历的列表，访问A的右节点，没有，返回上一级，此时存储列表为$[A]$。
这时候返回B，B加入列表中，然后访问B的右节点（先左再跟再右节点）D，访问D的左节点C，访问C的左节点不存在，C加入存储列表中，访问C的右节点不存在，返回上一级D，D加入存储列表中，访问D的右节点E，访问E的左节点不存在，回到E中，E加入列表，访问E的右节点，不存在，返回到D，返回到B，返回到F，F加入到列表中，此时列表为$[A,B,C,D,E,F]$。
接下来访问F的右节点G，访问G的左节点，不存在，G加入列表中，访问G的右节点I，访问I的左节点H，访问H的左节点，不存在返回I，I加入列表，访问I的右节点，不存在，返回G，返回F。
此时列表为$[A,B,C,D,E,F,G,H,I]$

1.3 树的后序遍历

同理可以得到树的后序遍历
$[A,C,E,D,B,H,I,G,F]$

2. 树的前序遍历代码实现

2.1 递归方法，时间复杂度$O(n)$，空间复杂度$O(n)$

class Solution(object):
    def preorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        def preorder(root):
            # print(res)
            if not root:
                return
            res.append(root.val)
            preorder(root.left)
            preorder(root.right)

        res = []
        preorder(root)
        return res

2.2 迭代方法，时间复杂度$O(n)$，空间复杂度$O(n)$

class Solution(object):
    def preorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        
        res = []
        if not root: return res
        stack = []
        node = root

        while node or stack:
            while node:
                res.append(node.val)
                stack.append(node)
                node = node.left
            # print('quit node left round')
            node = stack.pop()
            node = node.right
        return res

3. 树的中序遍历代码实现

跟前序遍历思路一样

3.1 递归方法

class Solution(object):
    def inorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        def inorder(root):
            if not root:
                return
            inorder(root.left)
            res.append(root.val)
            inorder(root.right)

        res = []
        inorder(root)

3.2 迭代方法

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

4.树的后序遍历代码实现

4.1 递推实现

class Solution(object):
    def postorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        def postorder(root):
            if not root:
                return
            postorder(root.left)
            postorder(root.right)
            res.append(root.val)

        res = []
        root = postorder(root)
        return res

4.2 迭代实现

class Solution(object):
    def postorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        res = []
        if not root: return res
        stack = []
        p = root
        prev = None

        while p or stack:
            while p:
                stack.append(p)
                p = p.left
            p = stack.pop()
            if not p.right or p.right == prev:
                res.append(p.val)
                prev = p
                p = None
            else:
                stack.append(p)
                p = p.right
        return res