二叉树算法实战：遍历与重构深度解析

1. 二叉树算法实战：从遍历到重构的深度解析

今天我想分享三个经典的二叉树算法题目，它们分别考察了二叉树的不同操作方式：层序遍历、路径搜索和结构重构。这些题目在面试和日常编码中都非常常见，掌握它们能帮助我们建立扎实的树形数据结构基础。

2. 513. 找树左下角的值

2.1 问题理解与解法选择

题目要求找出二叉树最底层最左边的节点值。这个问题看似简单，但需要考虑几个关键点：

• 如何确定"最底层"？
• 如何保证找到的是该层"最左边"的节点？
• 如何处理只有一个节点的情况？

层序遍历（BFS）是解决这类层级相关问题的自然选择，因为它能按层级顺序遍历节点，方便我们定位到最后一层。

2.2 层序遍历实现详解

cpp复制class Solution {
public:
    int findBottomLeftValue(TreeNode* root) {
        int res;
        deque<TreeNode*> dq;
        dq.push_back(root);
        while (!dq.empty()) {
            int sz = dq.size();
            for (int i = 0; i < sz; i++) {
                TreeNode* tmp = dq.front();
                dq.pop_front();
                if (!tmp->left && !tmp->right)
                    if (i == 0)
                        res = tmp->val;
                if (tmp->left)
                    dq.push_back(tmp->left);
                if (tmp->right)
                    dq.push_back(tmp->right);
            }
        }
        return res;
    }
};

这段代码有几个值得注意的细节：

1. 使用双端队列（deque）实现BFS，相比普通队列性能更好
2. 每次处理一层前先记录当前队列大小（sz），确保处理完完整一层
3. 对于每层的第一个叶子节点（i==0且左右子节点为空）记录其值

提示：在实际面试中，可以指出这种解法的时间复杂度是O(n)，空间复杂度在最坏情况下也是O(n)（当树退化为链表时）。

2.3 替代解法：DFS思路

虽然BFS更直观，但DFS也可以解决这个问题。我们可以记录遍历时的深度，当遇到更深的第一个节点时更新结果：

cpp复制class Solution {
public:
    int findBottomLeftValue(TreeNode* root) {
        int maxDepth = -1, res = 0;
        function<void(TreeNode*, int)> dfs = [&](TreeNode* node, int depth) {
            if (!node) return;
            if (depth > maxDepth) {
                maxDepth = depth;
                res = node->val;
            }
            dfs(node->left, depth + 1);
            dfs(node->right, depth + 1);
        };
        dfs(root, 0);
        return res;
    }
};

这种DFS解法同样高效，且代码更简洁。它利用了DFS会优先访问左子树的特性，确保在相同深度下总是先访问左侧节点。

3. 112. 路径总和

3.1 基础问题解析

题目要求判断二叉树中是否存在从根到叶子的路径，其节点值之和等于给定目标值。这需要：

1. 遍历所有根到叶子的路径
2. 计算每条路径的和
3. 与目标值比较

DFS是这类路径遍历问题的标准解法，因为它天然适合探索单条路径到底。

3.2 DFS解法实现

cpp复制class Solution {
public:
    bool hasPathSum(TreeNode* root, int targetSum) {
        bool res = false;
        auto dfs = [&](this auto&& dfs, TreeNode* node, int last) {
            if (!node)
                return;
            if (res)
                return;
            last += node->val;
            if (!node->left && !node->right) {
                if (last == targetSum)
                    res = true;
            }
            if (node->left)
                dfs(node->left, last);
            if (node->right)
                dfs(node->right, last);
        };
        dfs(root, 0);
        return res;
    }
};

关键点说明：

• 使用lambda表达式实现DFS，避免了额外的类成员变量
• last参数累积当前路径和
• 遇到叶子节点时检查是否匹配目标值
• 一旦找到匹配路径立即设置res并提前终止其他搜索（if(res) return;）

3.3 扩展：返回所有匹配路径

如果需要返回所有符合条件的路径而不仅仅是判断存在性，我们需要记录路径节点：

cpp复制class Solution {
public:
    vector<vector<int>> pathSum(TreeNode* root, int targetSum) {
        vector<vector<int>> res;
        vector<int> tmp;
        auto dfs = [&](this auto&& dfs, TreeNode* node, int pre) {
            if (!node)
                return;
            pre += node->val;
            tmp.push_back(node->val);
            if (!node->left && !node->right) {
                if (pre == targetSum)
                    res.push_back(tmp);
            }
            if (node->left)
                dfs(node->left, pre);
            if (node->right)
                dfs(node->right, pre);
            tmp.pop_back();
        };

        dfs(root, 0);
        return res;
    }
};

这个版本引入了回溯思想：

1. tmp向量记录当前路径
2. 访问节点时加入路径
3. 离开节点时弹出（回溯）
4. 找到匹配路径时复制当前路径到结果集

注意：这里必须复制tmp而不是直接引用，因为tmp会在回溯过程中被修改。

4. 106. 从中序与后序遍历序列构造二叉树

4.1 问题理解与难点分析

这是二叉树重构的经典问题，给定中序和后序遍历序列，要求重建原始二叉树。主要难点在于：

1. 理解两种遍历序列的特性
2. 准确定位根节点和左右子树的范围
3. 正确处理边界情况（空树、单节点树等）

4.2 核心算法思路

1. 后序遍历的最后一个元素总是当前子树的根节点
2. 在中序遍历中找到这个根节点，左侧即为左子树，右侧为右子树
3. 递归构建左右子树

4.3 完整实现代码

cpp复制class Solution {
public:
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        unordered_map<int, int> inMap;
        for (int i = 0; i < inorder.size(); i++)
            inMap[inorder[i]] = i;
        
        function<TreeNode*(int, int, int, int)> build = [&](int inStart, int inEnd, int postStart, int postEnd) {
            if (inStart > inEnd) return (TreeNode*)nullptr;
            
            TreeNode* root = new TreeNode(postorder[postEnd]);
            int inRoot = inMap[root->val];
            int numsLeft = inRoot - inStart;
            
            root->left = build(inStart, inRoot - 1, postStart, postStart + numsLeft - 1);
            root->right = build(inRoot + 1, inEnd, postStart + numsLeft, postEnd - 1);
            
            return root;
        };
        
        return build(0, inorder.size() - 1, 0, postorder.size() - 1);
    }
};

4.4 关键点解析

1. 使用哈希表存储中序遍历的值到索引的映射，实现O(1)时间的根节点查找
2. 计算左子树的节点数量（numsLeft）来确定后序遍历中的分割点
3. 递归构建时注意区间边界：
   • 中序左子树：[inStart, inRoot-1]
   • 中序右子树：[inRoot+1, inEnd]
   • 后序左子树：[postStart, postStart+numsLeft-1]
   • 后序右子树：[postStart+numsLeft, postEnd-1]

4.5 复杂度分析

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

5. 常见问题与调试技巧

5.1 层序遍历中的常见错误

1. 忘记处理空树情况：应在开始时检查root是否为nullptr
2. 错误判断叶子节点：必须同时检查左右子节点都为空
3. 队列处理不当：确保在子节点入队前检查非空

5.2 路径总和问题调试技巧

1. 打印路径跟踪：在DFS中加入调试输出，打印当前路径和累计值
2. 边界情况测试：
   • 空树
   • 单节点树
   • 目标值为0
   • 负数值节点

5.3 树重构问题注意事项

1. 确保遍历序列输入正确：检查中序和后序序列长度是否一致
2. 处理重复元素：如果有重复值，上述解法可能失效，需要额外处理
3. 内存管理：在实际应用中要注意释放树内存，避免泄漏

6. 扩展思考

6.1 从前序和中序序列构建树

类似后序+中序的思路，但前序的第一个元素是根节点：

cpp复制TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
    unordered_map<int, int> inMap;
    for (int i = 0; i < inorder.size(); i++)
        inMap[inorder[i]] = i;
    
    function<TreeNode*(int, int, int, int)> build = [&](int preStart, int preEnd, int inStart, int inEnd) {
        if (preStart > preEnd) return (TreeNode*)nullptr;
        
        TreeNode* root = new TreeNode(preorder[preStart]);
        int inRoot = inMap[root->val];
        int numsLeft = inRoot - inStart;
        
        root->left = build(preStart + 1, preStart + numsLeft, inStart, inRoot - 1);
        root->right = build(preStart + numsLeft + 1, preEnd, inRoot + 1, inEnd);
        
        return root;
    };
    
    return build(0, preorder.size() - 1, 0, inorder.size() - 1);
}

6.2 迭代解法探索

上述问题都可以用迭代法实现。例如路径总和的迭代DFS：

cpp复制bool hasPathSum(TreeNode* root, int targetSum) {
    if (!root) return false;
    stack<pair<TreeNode*, int>> st;
    st.push({root, root->val});
    while (!st.empty()) {
        auto [node, sum] = st.top();
        st.pop();
        if (!node->left && !node->right && sum == targetSum)
            return true;
        if (node->right)
            st.push({node->right, sum + node->right->val});
        if (node->left)
            st.push({node->left, sum + node->left->val});
    }
    return false;
}

这种迭代解法使用显式栈代替递归，避免了递归深度限制问题。