这是一道 简单 题

https://leetcode.cn/problems/binary-tree-inorder-traversal/

题目

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

示例 1：

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

示例 2：

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

示例 3：

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

提示：

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

---

题解

首先要知道什么是 中序遍历，这个 中 指的是遍历得到的结果中，根节点是在中间的，即遍历结果为：左子树 -> 根 -> 右子树。

那么前序遍历就是：根 -> 左子树 -> 右子树。

后续遍历就是：左子树 -> 右子树 -> 根。

不管是前序，中序，还是后序，都是递归的思路。

本题要求中序遍历，那么递归函数的逻辑就可以定义为：

1. 先遍历左子树，得到结果。
2. 再加上跟节点的值。
3. 最后再加上遍历右子树的结果。

其中遍历左右子树的时候，还是调用上面定义的这个递归函数，逐层递归，直到遇到边界条件。

边界条件为：遇到空节点，返回。

Java 代码实现

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {

        List<Integer> ans = new ArrayList<>();
        dfs(root, ans);
        return ans;

    }

    private void dfs(TreeNode node, List<Integer> ans){
        if(node == null){
            return;
        }
       
        dfs(node.left, ans);

        ans.add(node.val);
        
        dfs(node.right, ans);
    }
}

Go 代码实现

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */

func inorderTraversal(root *TreeNode) []int {
    ans := make([]int, 0)
    dfs(root, &ans)

    return ans

}

func dfs(node *TreeNode, ans *[]int) {
    if node == nil {
        return
    }

    dfs(node.Left, ans)

    *ans = append(*ans, node.Val)

    dfs(node.Right, ans)
}

复杂度分析

时间复杂度: $O(N)$，N 为二叉树中的节点个数，每个节点都需要遍历一次。

空间复杂度: $O(N)$，N 为二叉树中的节点个数，空间复杂度为调用栈的深度，最差的情况为 N。