二叉树的前中后序遍历(python)

给你二叉树的根节点 root ，返回它节点值的 前中后序 遍历。

示例 1：

输入：root = [1,null,2,3]
输出：[1,2,3]

示例 2：

输入：root = []
输出：[]

示例 3：

输入：root = [1]
输出：[1]

1.递归

前序遍历中左右(力扣144)

# 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]:
        result=[] #保存结果
        def func(root):
            if root==None:
                return 
            result.append(root.val)
            func(root.left)
            func(root.right)
        func(root)
        return result

中序遍历左中右(力扣94)

# 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]:
        result=[]
        def func(root):
            if root==None:
                return
            func(root.left)
            result.append(root.val)
            func(root.right)
        func(root)
        return result

后序遍历左右中(力扣145)

# 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]:
        result=[]
        def func(root):
            if root==None:
                return
            func(root.left)
            func(root.right)
            result.append(root.val)
        func(root)
        return result

2.迭代

前序遍历

# 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]:
        result=[]
        if root==None:
            return result
        stack=[root] #先把根结点放入栈
        while stack:
            node=stack.pop()  #出栈，出栈的顺序为根结点，左孩子，右孩子
            result.append(node.val) 
            if node.right:  #右孩子先进栈，后出
                stack.append(node.right)
            if node.left:   #左孩子后进栈，先出
                stack.append(node.left)
        return result

中序遍历

# 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]:
        result=[]
        if root==None:
            return result
        cur=root
        stack=[] #根结点不能先放入栈
        while stack or cur:
            if cur:  #指针来访问结点，访问到最底层
                stack.append(cur)
                cur=cur.left  
            else:
                cur=stack.pop() #底层的结点先出栈
                result.append(cur.val) 
                cur=cur.right 
        return result

后序遍历

# 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]:
        result=[]
        if root==None:
            return result
        stack=[root] #根结点先放入栈
        while stack:
            node=stack.pop()
            result.append(node.val)
            if node.left:
                stack.append(node.left)
            if node.right:
                stack.append(node.right)
        return result[::-1]  #中右左进result，最后反转为左右中