Java二叉树算法实战：高频面试题精解与优化-代码聚汇网

Java二叉树算法实战：高频面试题精解与优化

东予薏米

1. 二叉树算法实战精要

作为Java开发者，刷题路上遇到二叉树相关题目总是让人又爱又恨。今天咱们就来深度剖析力扣Hot100系列中几道经典的二叉树题目，这些题目在面试中的出现频率高达75%以上。不同于教科书式的算法讲解，我会结合自己在大厂面试和实际工程中的经验，分享真正实用的解题思路和优化技巧。

先说说这几道题的特殊性：它们都涉及到二叉树的非线性结构特性，需要处理递归与迭代的平衡，同时考察对树遍历的深刻理解。比如"从前序与中序遍历序列构造二叉树"这道题，我在字节跳动的三面中就遇到过变种题目，面试官要求同时优化时间和空间复杂度。而"二叉树中的最大路径和"则是亚马逊面试官最爱考察的题目之一，因为它能同时检验候选人对递归和动态规划的理解程度。

2. 从前序与中序遍历序列构造二叉树

2.1 问题本质与核心思路

给定一棵二叉树的前序遍历和中序遍历结果，要求重建原始二叉树结构。这道题的难点在于如何高效地定位根节点和左右子树的分界点。

前序遍历的第一个元素必然是根节点，这个特性是我们的突破口。在中序遍历中找到这个根节点后，其左侧就是左子树的所有节点，右侧则是右子树的所有节点。这个分界点至关重要，它决定了我们如何划分前序遍历序列。

关键技巧：使用HashMap存储中序遍历的值到索引的映射，可以将查找操作的时间复杂度从O(n)降到O(1)。

2.2 Java实现与优化细节

java复制class Solution {
    private Map<Integer, Integer> indexMap;
    
    public TreeNode buildTree(int[] preorder, int[] inorder) {
        indexMap = new HashMap<>();
        for (int i = 0; i < inorder.length; i++) {
            indexMap.put(inorder[i], i);
        }
        return helper(preorder, 0, preorder.length - 1, 
                     inorder, 0, inorder.length - 1);
    }
    
    private TreeNode helper(int[] preorder, int preStart, int preEnd,
                          int[] inorder, int inStart, int inEnd) {
        if (preStart > preEnd || inStart > inEnd) return null;
        
        TreeNode root = new TreeNode(preorder[preStart]);
        int inRoot = indexMap.get(root.val);
        int numsLeft = inRoot - inStart;
        
        root.left = helper(preorder, preStart + 1, preStart + numsLeft,
                         inorder, inStart, inRoot - 1);
        root.right = helper(preorder, preStart + numsLeft + 1, preEnd,
                          inorder, inRoot + 1, inEnd);
        return root;
    }
}

这段代码有几个值得注意的优化点：

使用成员变量indexMap避免递归参数过多
通过numsLeft计算左子树节点数，精确划分前序数组
边界条件处理确保递归终止

2.3 复杂度分析与常见错误

时间复杂度：O(n)，每个节点被处理一次
空间复杂度：O(n)，存储哈希表和递归栈

常见坑点：

忽略输入数组为空的情况
错误计算左右子树的分界点
递归终止条件写错导致栈溢出

我在第一次实现时就犯了一个典型错误：没有正确处理前序数组的索引计算，导致构建的树结构完全错乱。后来通过画图逐步调试才找到问题所在。

3. 路径总和III

3.1 双重递归与前缀和优化

这道题要求找出二叉树中路径和等于目标值的路径数量，路径不需要从根节点开始或到叶子节点结束。这种灵活性使得暴力解法的时间复杂度达到O(n²)。

更高效的解法是使用前缀和+哈希表，将时间复杂度优化到O(n)。这个思路借鉴了数组中的子数组和问题，但在二叉树中的应用需要特别注意回溯时的状态恢复。

3.2 Java实现与回溯技巧

java复制class Solution {
    public int pathSum(TreeNode root, int targetSum) {
        Map<Long, Integer> prefixSumCount = new HashMap<>();
        prefixSumCount.put(0L, 1);
        return dfs(root, prefixSumCount, 0, targetSum);
    }
    
    private int dfs(TreeNode node, Map<Long, Integer> prefixSumCount, 
                   long currSum, int target) {
        if (node == null) return 0;
        
        currSum += node.val;
        int res = prefixSumCount.getOrDefault(currSum - target, 0);
        
        prefixSumCount.put(currSum, prefixSumCount.getOrDefault(currSum, 0) + 1);
        
        res += dfs(node.left, prefixSumCount, currSum, target);
        res += dfs(node.right, prefixSumCount, currSum, target);
        
        prefixSumCount.put(currSum, prefixSumCount.get(currSum) - 1);
        return res;
    }
}

关键点解析：

使用Long类型避免整数溢出
初始放入(0,1)表示和为0的路径有1条
回溯时及时更新哈希表，防止影响其他路径

3.3 性能对比与适用场景

暴力解法虽然直观，但在最坏情况下（树退化为链表）性能极差。前缀和解法虽然需要额外空间，但能保证线性时间复杂度。在实际面试中，面试官通常会期待候选人能提出前缀和的优化方案。

4. 二叉树的最近公共祖先

4.1 LCA问题经典解法

最近公共祖先(LCA)问题是二叉树算法中的经典问题。对于普通二叉树（非BST），我们需要考虑节点可能不存在等边界情况。

递归解法基于这样一个观察：如果一个节点的左右子树分别包含p和q，那么这个节点就是LCA。这个思路简洁优雅，但需要仔细处理各种边界条件。

4.2 Java实现与递归理解

java复制class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        if (root == null || root == p || root == q) return root;
        
        TreeNode left = lowestCommonAncestor(root.left, p, q);
        TreeNode right = lowestCommonAncestor(root.right, p, q);
        
        if (left != null && right != null) return root;
        return left != null ? left : right;
    }
}

这段代码的精妙之处在于：

递归终止条件同时处理null和找到p/q的情况
后序遍历确保先处理子树再判断当前节点
简洁的三元表达式返回结果

4.3 非递归解法与工程实践

虽然递归解法简洁，但在工程实践中，对于深度很大的树可能会引发栈溢出。这时可以考虑使用非递归解法，通过父指针映射或迭代遍历来实现。

java复制class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        Map<TreeNode, TreeNode> parent = new HashMap<>();
        Deque<TreeNode> stack = new ArrayDeque<>();
        parent.put(root, null);
        stack.push(root);
        
        while (!parent.containsKey(p) || !parent.containsKey(q)) {
            TreeNode node = stack.pop();
            if (node.left != null) {
                parent.put(node.left, node);
                stack.push(node.left);
            }
            if (node.right != null) {
                parent.put(node.right, node);
                stack.push(node.right);
            }
        }
        
        Set<TreeNode> ancestors = new HashSet<>();
        while (p != null) {
            ancestors.add(p);
            p = parent.get(p);
        }
        while (!ancestors.contains(q)) {
            q = parent.get(q);
        }
        return q;
    }
}

这种解法虽然代码量较大，但更适合处理大规模数据。在面试中，可以先给出递归解法，再讨论非递归优化的可能性。

5. 二叉树中的最大路径和

5.1 问题分析与递归定义

这道题要求找出二叉树中任意节点到任意节点的路径和的最大值。路径至少包含一个节点，且不一定经过根节点。

关键点在于理解：对于每个节点，经过它的最大路径和可能是：

节点本身的值
节点值 + 左子树的最大路径
节点值 + 右子树的最大路径
节点值 + 左子树最大路径 + 右子树最大路径

5.2 Java实现与全局变量使用

java复制class Solution {
    private int maxSum = Integer.MIN_VALUE;
    
    public int maxPathSum(TreeNode root) {
        maxGain(root);
        return maxSum;
    }
    
    private int maxGain(TreeNode node) {
        if (node == null) return 0;
        
        int leftGain = Math.max(maxGain(node.left), 0);
        int rightGain = Math.max(maxGain(node.right), 0);
        
        int priceNewPath = node.val + leftGain + rightGain;
        maxSum = Math.max(maxSum, priceNewPath);
        
        return node.val + Math.max(leftGain, rightGain);
    }
}

实现细节：

使用全局变量maxSum跟踪最大值
maxGain返回的是以当前节点为起点的最大路径和
负收益的子树被舍弃（Math.max(..., 0)）

5.3 边界条件与测试用例

这道题特别容易忽略的边界情况包括：

所有节点都是负数的情况
只有一个节点的情况
超大数的溢出问题（虽然本题约束了数值范围）

建议测试用例：

[1,2,3] → 6
[-10,9,20,null,null,15,7] → 42
[-3] → -3
[2,-1] → 2

6. 二叉树问题通用解题框架

通过这几道题的练习，我总结出一个二叉树问题的通用解题框架：

明确遍历顺序：前序、中序还是后序？不同的顺序适用于不同场景
确定递归参数和返回值：哪些信息需要向下传递，哪些需要向上返回
处理边界条件：空节点、单节点等特殊情况
考虑优化空间：能否用迭代代替递归？能否利用前缀和等技巧？
设计测试用例：包括常规情况和各种边界情况

在实际面试中，建议按照以下步骤进行：

先明确问题要求，确认输入输出
举例说明自己的理解
提出暴力解法并分析复杂度
逐步优化，解释优化思路
编写代码，边写边解释
设计测试用例验证代码

记住，面试官更关注你的思考过程而非最终答案。遇到问题时，坦诚地讨论你的思路和困惑往往比沉默更好。