【二叉树】LeetCode 94. 二叉树的中序遍历【简单】

给定一个二叉树的根节点 root ，返回 它的 中序 遍历 。

示例1:

 

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

示例 2：

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

示例 3：

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

提示：

树中节点数目在范围 [0, 100] 内
-100 <= Node.val <= 100
 

进阶: 递归算法很简单，你可以通过迭代算法完成吗？

【分析】

知识点review：

先/前序遍历：根 左 右

中序遍历：左 根 右

后序遍历：左 右 根

方法一：递归实现

递归实现太简单了

• 前序遍历：打印 - 左 - 右
• 中序遍历：左 - 打印 - 右
• 后序遍历：左 - 右 - 打印

题目要求的是中序遍历，那就按照左-打印-右这种顺序遍历树就可以了，递归函数实现

• 终止条件：当前节点为空时
• 函数内：递归的调用左节点，打印当前节点，再递归调用右节点

时间复杂度：O(n)

空间复杂度：O(h)，h指树的高度

# 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: TreeNode) -> List[int]:
        res = []
        def dfs(root):
            if not root:
                return 
            # 按照 左-打印-右的方式遍历    
            dfs(root.left)
            res.append(root.val) # 注意取值写法“root.val”
            dfs(root.right)
        dfs(root)
        return res

方法二：迭代实现

本题的真正难点在于如何用非递归的方式实现。

递归实现是函数自己调用自己，一层一层嵌套调用下去，操作系统自动帮助我们用栈来保存了每一个调用的函数，现在我们需要自己模拟这样的调用过程。

递归的调用过程是这样的：

dfs(root.left)
    dfs(root.left)
        dfs(root.left)
            为null返回
        # 打印节点
        dfs(root.right)
            dfs(root.right)
                dfs(root.right)
                ……

递归的调用过程是不断往左边走，当左边走不下去了，就打印节点，并转向右边，然后右边继续这个过程。

我们在迭代实现时，就可以用栈来模拟上面的调用过程。

时间复杂度：O(n)，

空间复杂度：O(h)，h是树的高度。

# 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: TreeNode) -> List[int]:
        res = []
        stack = []
        while stack or root:
            # 不断往左子树方向走，每走一次就将当前节点保存到栈中
            # 这是模拟递归的调用
            if root:
                stack.append(root)
                root = root.left
            # 当前节点为空，说明左边走到头了，从栈中弹出节点并保存
            # 然后转向右边节点，继续上面整个过程
            else:
                tmp = stack.pop()
                res.append(tmp.val) # 注意取值写法
                root = tmp.right
        return res

方法三：莫里斯遍历

用递归和迭代的方式都使用了辅助空间，而莫里斯遍历的优点是没有使用任何辅助空间。缺点是改变了整个树树的结构，强行把一棵二叉树改成一段链表结构。

 

我们将黄色区域部分挂到节点5的右子树上（橙色箭头），接着再把2和5这两个节点挂到节点4的右边。这样整棵树基本上就变成了一个链表了，之后再不断往右遍历。

时间复杂度：O(n)，找到每个前驱节点的复杂度是O(n)，因为n个节点的二叉树有n-1条边，每条边只可能使用两次（一次定位到节点，一次找到前驱节点），故时间复杂度为O(n)。

空间复杂度：O(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 inorderTraversal(self, root: TreeNode) -> List[int]:
        res = []
        pre = None
        while root:
            # 若左节点不为空，就将当前节点连带右子树全部挂在左节点的最右子树下面
            if root.left:
                pre = root.left
                while pre.right:
                    pre = pre.right
                pre.right = root
                # 将root指向root的left
                tmp = root
                root = root.left
                tmp.left = None
            # 左子树为空，则打印这个节点，并向右遍历
            else:
                res.append(root.val)
                root = root.right
        return res

# 作者：wang_ni_ma
# 链接：https://leetcode.cn/problems/binary-tree-inorder-traversal/solution/dong-hua-yan-shi-94-er-cha-shu-de-zhong-xu-bian-li/
# 来源：力扣（LeetCode）
# 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。