二叉树的前、中、后序遍历 两种解法（Python）

​

递归解法 时间复杂度 O(N)

中序

# 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]:
        if not root: return []
        res_list = []
        def inorder(root: Optional[TreeNode]):
            if not root:
                return
            # 差别在于此处的顺序变化
            inorder(root.left)
            res_list.append(root.val)
            inorder(root.right)
        inorder(root)
        return res_list

前序

# 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]:
        res_list = []
        def preorder(root: Optional[TreeNode]):
            if not root:
                return
            res_list.append(root.val)
            preorder(root.left)
            preorder(root.right)
        preorder(root)
        return res_list

后序

# 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]:
        res_list = []
        def postorder(root: Optional[TreeNode]):
            if not root:
                return
            postorder(root.left)
            postorder(root.right)
            res_list.append(root.val)
        postorder(root)
        return res_list

迭代 时间复杂度 O(N)

如果理解有难度的话，可以直接举例一个最简单情况的遍历，比如下图

写的时候就参考这个情况的遍历，就会清晰很多

中序

中序遍历的解法其实是个通用模板解法 只需简单调整就可以变为 前序和后续的解法

# 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]:
        if not root: return []
        res_list, stack, cur = [], [], root
        while cur or stack:
            # 先到达最左边的节点 并记录沿途节点
            while cur:
                stack.append(cur)
                cur = cur.left
            # 此时 栈顶节点没有左子节点
            tmp = stack.pop()
            # 保存根的值
            res_list.append(tmp.val)
            # 没有左子节点 根的值已经保存 则到右节点啦~
            cur = tmp.right
        return res_list

前序

模板解法

# 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]:
        if not root: return []
        res_list, stack, cur = [], [], root
        while cur or stack:
            # 相当于一次性把 根的值和左子节点的值都记录了
            while cur:
                res_list.append(cur.val)
                # 当前节点入栈 之后会处理右节点
                stack.append(cur)
                cur = cur.left
            tmp = stack.pop()
            cur = tmp.right
        return res_list

常规解法

# 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]:
        if not root: return []
        res_list, stack = [], [root]
        while stack:
            tmp = stack.pop()
            res_list.append(tmp.val)
            # 栈 先进后出
            # 先加右节点 再加左节点
            # pop时 左节点先出 保证 根 - 左 - 右
            if tmp.right:
                stack.append(tmp.right)
            if tmp.left:
                stack.append(tmp.left)
        return res_list

后序

模板解法

# 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 []
        res_list, stack, cur = [], [], root
        while stack or cur:
            while cur:
                # 根
                res_list.append(cur.val)
                stack.append(cur)
                # 向右
                cur = cur.right
            tmp = stack.pop()
            # 再左
            cur = tmp.left
        # 左-右-根 为 根-右-左 的 反向
        return res_list[::-1]

常规解法

# 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 []
        res_list, stack = [], [(0, root)]
        while stack:
            flag, tmp = stack.pop()
            # 此时 若状态为1 说明
            # 1、此根节点的子节点均已入过栈 （子节点比根节点靠近栈顶）
            # 2、此根节点的子节点均已加入结果
            # 则直接将其加入结果即可
            if flag == 1:
                res_list.append(tmp.val)
            else:
                # 当前节点状态为0，表明还未将其子节点加入栈中。此时，将其和其左右子节点再次入栈，同时修改其状态为1，表明其子节点已经入栈
                # 入栈顺序 为 左-右-根 的反向 根-右-左 子节点靠近栈顶 根节点靠近栈底
                stack.append((1, tmp))
                if tmp.right:
                    stack.append((0, tmp.right))
                if tmp.left:
                    stack.append((0, tmp.left))
        return res_list