二叉树的前，中，后序遍历（递归法和迭代法） Python

二叉树的前序遍历

递归法：

# 定义二叉树节点的类
# class TreeNode:
#    def __init__(self, x):
#        self.val == x
#        self.left == None
#        self.right == None

class Solution:
    def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        res = []  # 用于存储前序遍历结果的列表
        # 定义一个递归函数，实现前序遍历
        def pre_order(root):
            if not root:  # 如果当前节点为空，则返回
                return 
            res.append(root.val)  # 将当前节点的值加入到结果列表中
            pre_order(root.left)  # 递归遍历左子树
            pre_order(root.right)  # 递归遍历右子树
        pre_order(root)  # 调用递归函数进行前序遍历
        return res  # 返回前序遍历结果的列表

迭代法：

class Solution:
    def preorderTraversal(self, root: TreeNode) -> List[int]:
        # 如果根结点为空，则返回空列表
        if not root:
            return []
        stack = [root]  # 把根节点存放在栈里
        result = []  # 用于存储遍历结果
        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  # 返回先序遍历结果

二叉树的中序遍历：

递归法：

# 定义二叉树节点的类
# 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]:
        res = []

        # 定义一个中序遍历的辅助函数
        def in_order(root):
            # 如果当前节点为空，直接返回
            if not root:
                return
            # 递归遍历左子树
            in_order(root.left)
            # 将当前节点的值加入结果列表
            res.append(root.val)
            # 递归遍历右子树
            in_order(root.right)

        # 调用中序遍历函数
        in_order(root)
        # 返回结果列表
        return res

迭代法：

# 中序遍历-迭代-LC94_二叉树的中序遍历
class Solution:
    def inorderTraversal(self, root: TreeNode) -> List[int]:
        if not root:
            return []
        stack = []  # 不能提前将root结点加入stack中
        res = []
        cur = root
        while cur or stack:  # 当当前结点不为空或栈不为空时循环
            if cur:  # 如果当前结点不为空
                stack.append(cur)  # 将当前结点压入栈中
                cur = cur.left  # 将当前结点移动到左子结点
            else:  # 如果当前结点为空
                cur = stack.pop()  # 弹出栈顶结点并将其赋给当前结点
                res = cur.right  # 将当前结点移动到右子结点

        return res  # 返回中序遍历结果列表

二叉树的后续遍历：

递归法：

class Solution:
    def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        res = []

        # 定义一个后序遍历的辅助函数
        def post_order(root):
            # 如果当前节点为空，直接返回
            if not root:
                return
            # 递归遍历左子树
            post_order(root.left)
            # 递归遍历右子树
            post_order(root.right)
            # 将当前节点的值加入结果列表
            res.append(root.val)

        # 调用后序遍历函数
        post_order(root)
        # 返回结果列表
        return res

迭代法：

后序遍历的迭代法跟前序类似，前序是中，左，右的顺序    后序是左，右，中的顺序， 只需把前序的左跟右换个位置再把取出来的元素逆序排序就行了

# 定义一个二叉树节点
# 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 []
        # 初始化结果列表和栈
        res = []
        stack = [root]
        # 循环直到栈为空
        while stack:
            # 弹出栈顶节点
            node = stack.pop()
            # 将节点值加入结果列表
            res.append(node.val)
            # 如果有左子节点，将左子节点加入栈
            if node.left:
                stack.append(node.left)
            # 如果有右子节点，将右子节点加入栈
            if node.right:
                stack.append(node.right)           
        # 返回结果列表的逆序（即后序遍历的顺序）
        return res[::-1]