二叉树的遍历-----递归和迭代模板总结~超简单。

先序: 左右根
中序: 左根右
后序: 左右根

先说递归：

先序:

def preTraversal(self, root: TreeNode) -> List[int]:
    res = []
    def dfs(root):
        if root:
            res.append(root.val) # 访问根节点
            dfs(root.left)	# 递归左
            dfs(root.right)	# 递归右
    dfs(root)
    return res

中序:

def inorderTraversal(self, root: TreeNode) -> List[int]:
    res = []
    def dfs(root):
        if root:
            dfs(root.left)
            res.append(root.val)
            dfs(root.right)
    dfs(root)
    return res

后序:

def laterTraversal(self, root: TreeNode) -> List[int]:
    res = []
    def dfs(root):
        if root:
            dfs(root.left)
            dfs(root.right)
            res.append(root.val)
    dfs(root)
    return res

迭代:

先序:

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        stack = []
        res = []
        if not root:
            return []
        stack.append(root)
        while len(stack)!=0:
            node = stack.pop()
            res.append(node.val)
            # 这里并不需要判断node是否为空，别忘了上面node是从栈里面拿出来的，node必然不是none。只需要判断他的左右孩子是不是none就行了。
            if node.right:
                stack.append(node.right)
            if node.left:
                stack.append(node.left)
        return res
            

中序:

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def inorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        stack = []
        if not root:
            return []
        res = []
        cur = root  # 设置cur为遍历指针
        while cur!=None or len(stack)!=0:
            # 首先一路遍历到最左下角,也可以理解成，
            # 一次while循环只走一次左或者右，如果左边一直有就一直走左边，左边没有了才走一次右边，走了一次右边之后又有左边了就又去走左边了，即左边有先走。
            if cur!=None:
                stack.append(cur)
                cur = cur.left
            else:
                # 最左下角没有左孩子了。按照左中右顺序走
                # 并且回退遍历指针到上一个地方。
                cur = stack.pop() 
                res.append(cur.val)
                cur = cur.right
        return res 

后序:

实际上后续和前序的迭代方法一样，只不过前序是 中左右，写后序的时候吧左右顺序换一下，变成了 中右左，最后得到的res数组再翻转一下，变成左右中就是后续了。

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        if not root:
            return []
        stack = []
        res = []
        stack.append(root)
        while len(stack)!=0:
            node = stack.pop()
            res.append(node.val)
            if node.left:
                stack.append(node.left)
            if node.right:
                stack.append(node.right)
        return res[::-1]          

递归的

迭代的