关于‘Leetcode105:从前序和中序遍历构造二叉树‘的一些个人思路

原创已于 2025-09-02 18:28:12 修改 · 747 阅读

9 ·

CC 4.0 BY-SA版权

文章标签：

#算法 #数据结构

于 2025-09-02 18:27:37 首次发布

先看题：

什么是二叉树的遍历？

先简单回顾下两种遍历方式：

前序遍历：先访问根节点，再遍历左子树，最后遍历右子树（根 -> 左 -> 右）
中序遍历：先遍历左子树，再访问根节点，最后遍历右子树（左 -> 根 -> 右）

比如一棵简单的树：

前序遍历就是：3,9,20,15,7
中序遍历就是：9,3,15,20,7

核心思路：怎么从两个数组还原树？

咱们的目标是：给你这两个数组，让你把树重新画出来。

关键发现：

前序遍历的第一个元素肯定是整个树的根节点（比如上面的 3）
在中序遍历里，根节点左边的都是左子树的节点，右边的都是右子树的节点（比如 3 左边的 9 是左子树，右边的 15,20,7 是右子树）

知道了这个，就能分步骤来：

找根节点（前序数组第一个）
确定左子树有多少个节点（看中序数组里根节点左边有几个元素）
把前序和中序数组都分成左子树和右子树两部分
递归处理左子树和右子树

代码里具体怎么做的？

第一步：建立索引表

先把中序遍历的每个值和它的位置存到哈希表里，这样查根节点在中序里的位置时就能一步到位，不用每次都遍历查找。

Map<Integer,Integer> index = new HashMap<>(n);
for(int i = 0;i < n;i++){
    index.put(inorder[i],i);  // 键是节点值，值是在中序数组里的索引
}

第二步：递归构建树

递归函数dfs的参数有点多，咱们一个个看：

preL, preR：当前处理的前序数组范围（从 preL 到 preR，包含 preL，不包含 preR）
inL, inR：当前处理的中序数组范围（同上）
index：就是上面建的哈希表

具体步骤：

终止条件：如果 preL 等于 preR，说明这段里没节点了，返回 null
找根节点：前序数组里 preL 位置的元素就是当前子树的根节点值
算左子树大小：在中序数组里找到根节点的位置，减去 inL，就是左子树的节点数

比如根节点在中序里的位置是 x，那么左子树就有 x - inL 个节点
递归建左子树：
- 前序范围：preL+1 到 preL+1 + 左子树大小（因为前序里根后面紧跟着左子树）
- 中序范围：inL 到 inL + 左子树大小（中序里根左边是左子树）
递归建右子树：
- 前序范围：preL+1 + 左子树大小到 preR（剩下的都是右子树）
- 中序范围：inL + 左子树大小 + 1 到 inR（中序里根右边是右子树）
组装节点：用根节点值、左子树、右子树创建一个新节点并返回

举个例子走一遍

还是用前面的例子：
前序：[3,9,20,15,7]
中序：[9,3,15,20,7]

第一次调用：

preL=0, preR=5（整个前序数组）
inL=0, inR=5（整个中序数组）
根节点是 preorder [0]=3
在中序里找 3 的位置是 1，所以左子树大小 = 1-0=1

左子树递归：

前序范围：1 到 2（即 [9]）
中序范围：0 到 1（即 [9]）
根是 9，左右都为空，所以这是个叶子节点

右子树递归：

前序范围：2 到 5（即 [20,15,7]）
中序范围：2 到 5（即 [15,20,7]）
根是 20，在中序里位置是 3，左子树大小 = 3-2=1

就这样一层一层递归下去，整个树就建起来了。

代码优点在哪？

用哈希表存中序索引，查找根节点位置是 O (1)，比每次遍历快多了
用索引范围来划分数组，不用真的切割数组，节省空间
递归思路清晰，把大问题拆成小问题，容易理解

可能遇到的疑问

为什么树里不能有重复元素？因为哈希表会覆盖相同的值，就找不到正确的位置了
时间复杂度：每个节点处理一次，哈希表插入和查找都是 O (1)，所以整体 O (n)
空间复杂度：哈希表存 n 个元素，递归最深可能到 n 层，所以 O (n)

完整代码：

class Solution {
    public TreeNode buildTree(int[] preorder, int[] inorder) {
        int n = preorder.length;
        // 创建中序遍历值到索引的映射，加速查找
        Map<Integer,Integer> index = new HashMap<>(n);
        for(int i = 0;i < n;i++){
            index.put(inorder[i],i);
        }
        // 调用递归函数构建二叉树
        return dfs(preorder,0,n,0,n,index);
    }
    
    /**
     * 递归构建二叉树
     * @param preorder 前序遍历数组
     * @param preL 前序遍历当前子树的起始索引（包含）
     * @param preR 前序遍历当前子树的结束索引（不包含）
     * @param inL 中序遍历当前子树的起始索引（包含）
     * @param inR 中序遍历当前子树的结束索引（不包含）
     * @param index 中序遍历值到索引的映射
     * @return 当前子树的根节点
     */
    private TreeNode dfs(int[] preorder,int preL,int preR,int inL,int inR,Map<Integer,Integer> index){
        // 递归终止条件：当前子树没有节点
        if(preL == preR){
            return null;
        }
        
        // 前序遍历的第一个元素是当前子树的根节点
        int rootVal = preorder[preL];
        // 计算左子树的节点数量
        int leftSize = index.get(rootVal) - inL;
        
        // 递归构建左子树
        TreeNode left = dfs(preorder,preL + 1,preL + 1 + leftSize,inL,inL + leftSize,index);
        // 递归构建右子树
        TreeNode right = dfs(preorder,preL + 1 + leftSize,preR,inL + leftSize + 1,inR,index);
        
        // 创建当前根节点并返回
        return new TreeNode(rootVal,left,right);
    }
}

这种通过两种遍历还原树的方法很经典，掌握了思路，不管是前序 + 中序，还是中序 + 后序，道理都差不多，都是利用遍历的特性来拆分问题～