训练营第十八天 | ● 513.找树左下角的值● 112. 路径总和 113.路径总和ii● 106.从中序与后序遍历序列构造二叉树 105.从前序与中序遍历序列构造二叉树

• 513.找树左下角的值

题目：

给定一个二叉树，在树的最后一行找到最左边的值。

示例 1:

示例 2:

递归法：

思路：

找到二叉树的最后一行，即深度最大的叶子节点，保证优先左边搜索，然后记录深度最大的叶子节点。

1. 确定递归函数的参数和返回值

参数必须有要遍历的树的根节点，还有就是一个int型的变量用来记录最长深度。 不需要返回值，所以递归函数的返回类型为void。

本题还需要类里的两个全局变量，maxLen用来记录最大深度，result记录最大深度最左节点的数值。

2. 确定终止条件

当遇到叶子节点的时候，需要统计最大的深度，所以需要遇到叶子节点来更新最大深度。

3. 确定单层递归的逻辑

在找最大深度的时候，递归的过程中依然要使用回溯。

class Solution {
public:
    int maxDepth = INT_MIN;  // 用于记录当前最大深度，初始化为最小整数值
    int result;              // 用于记录最深层的最左边节点的值

    // 辅助函数，递归遍历二叉树，寻找最深层的最左边节点
    void traversal(TreeNode* root, int depth) {
        // 如果当前节点是叶子节点
        if (root->left == NULL && root->right == NULL) {
            // 如果当前深度大于记录的最大深度，更新最大深度和结果值
            if (depth > maxDepth) {
                maxDepth = depth;
                result = root->val;
            }
            return;
        }

        // 递归遍历左子树
        if (root->left) {
            depth++;  // 增加深度
            traversal(root->left, depth);
            depth--;  // 回溯，恢复深度
        }

        // 递归遍历右子树
        if (root->right) {
            depth++;  // 增加深度
            traversal(root->right, depth);
            depth--;  // 回溯，恢复深度
        }

        return;
    }

    // 主函数，寻找二叉树最深层的最左边节点的值
    int findBottomLeftValue(TreeNode* root) {
        traversal(root, 0);  // 从根节点开始遍历，初始深度为0
        return result;       // 返回最深层的最左边节点的值
    }
};

迭代法：

思路：

层序遍历，找到最后一行的第一个节点即可。

class Solution {
public:
    // 主函数，寻找二叉树最深层的最左边节点的值
    int findBottomLeftValue(TreeNode* root) {
        queue<TreeNode*> que;  // 定义一个队列用于层次遍历
        if (root != NULL) que.push(root);  // 如果根节点不为空，将根节点入队
        int result = 0;  // 用于存储最终结果，即最深层最左边节点的值

        // 开始层次遍历
        while (!que.empty()) {
            int size = que.size();  // 获取当前层的节点数

            // 遍历当前层的所有节点
            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();  // 取出队列中的第一个节点
                que.pop();  // 移除该节点

                // 记录当前层的第一个节点的值，即最左边节点的值
                if (i == 0) result = node->val;

                // 将左子节点入队
                if (node->left) que.push(node->left);

                // 将右子节点入队
                if (node->right) que.push(node->right);
            }
        }

        // 返回最深层的最左边节点的值
        return result;
    }
};

• 112. 路径总和

题目：

给定一个二叉树和一个目标和，判断该树中是否存在根节点到叶子节点的路径，这条路径上所有节点值相加等于目标和。

说明: 叶子节点是指没有子节点的节点。

示例: 给定如下二叉树，以及目标和 sum = 22，

返回 true, 因为存在目标和为 22 的根节点到叶子节点的路径 5->4->11->2。

思路：

1. 确定递归函数的参数和返回类型

参数：需要二叉树的根节点，还需要一个计数器来计算二叉树的一条边之和是否正好是目标和。

递归函数什么时候需要返回值？什么时候不需要返回值？这里总结如下三点：

• 如果需要搜索整棵二叉树且不用处理递归返回值，递归函数就不要返回值。（这种情况如113.路径总和ii）
• 如果需要搜索整棵二叉树且需要处理递归返回值，递归函数就需要返回值。 （这种情况如236. 二叉树的最近公共祖先 (opens new window)）
• 如果要搜索其中一条符合条件的路径，那么递归一定需要返回值，因为遇到符合条件的路径了就要及时返回。（本题的情况）

而本题我们要找一条符合条件的路径，所以递归函数需要返回值，及时返回，那么返回类型是什么呢？

如图所示：

图中可以看出，遍历的路线，并不要遍历整棵树，所以递归函数需要返回值，可以用bool类型表示。

2. 确定终止条件

首先计数器统计这一条路径的和，可以用递减，让计数器count初始为目标和，然后每次减去遍历路径节点上的数值。

如果最后count == 0，同时到了叶子节点的话，说明找到了目标和。

如果遍历到了叶子节点，count不为0，就是没找到。

3. 确定单层递归的逻辑

因为终止条件是判断叶子节点，所以递归的过程中就不要让空节点进入递归了。

递归函数是有返回值的，如果递归函数返回true，说明找到了合适的路径，应该立刻返回。

class Solution {
private:
    // 辅助函数，递归遍历二叉树，判断是否存在从根到叶子的路径，使得路径上所有节点值的和等于给定值
    bool traversal(TreeNode* cur, int count) {
        // 如果当前节点是叶子节点，并且计数为0，说明找到了符合条件的路径
        if (!cur->left && !cur->right && count == 0) return true; 

        // 如果当前节点是叶子节点但计数不为0，返回false
        if (!cur->left && !cur->right) return false; 

        // 递归处理左子树
        if (cur->left) {
            count -= cur->left->val; // 处理左子节点，将左子节点的值从计数中减去
            if (traversal(cur->left, count)) return true; // 递归遍历左子树，如果找到符合条件的路径，返回true
            count += cur->left->val; // 回溯，撤销处理结果
        }

        // 递归处理右子树
        if (cur->right) {
            count -= cur->right->val; // 处理右子节点，将右子节点的值从计数中减去
            if (traversal(cur->right, count)) return true; // 递归遍历右子树，如果找到符合条件的路径，返回true
            count += cur->right->val; // 回溯，撤销处理结果
        }

        // 如果没有找到符合条件的路径，返回false
        return false;
    }

public:
    // 主函数，判断是否存在从根到叶子的路径，使得路径上所有节点值的和等于给定值
    bool hasPathSum(TreeNode* root, int sum) {
        // 如果根节点为空，返回false
        if (root == NULL) return false;

        // 调用辅助函数，从根节点开始递归遍历，初始计数为sum减去根节点的值
        return traversal(root, sum - root->val);
    }
};

• 113.路径总和ii

题目：

给定一个二叉树和一个目标和，找到所有从根节点到叶子节点路径总和等于给定目标和的路径。

说明: 叶子节点是指没有子节点的节点。

示例: 给定如下二叉树，以及目标和 sum = 22，

思路：

113.路径总和ii要遍历整个树，找到所有路径，所以递归函数不要返回值！

class Solution {
private:
    vector<vector<int>> result; // 用于存储所有满足条件的路径
    vector<int> path; // 当前路径

    // 辅助函数，递归遍历二叉树，寻找和为目标值的路径
    void traversal(TreeNode* cur, int count) {
        // 如果当前节点是叶子节点，并且剩余目标和为0，说明找到了一个满足条件的路径
        if (!cur->left && !cur->right && count == 0) {
            result.push_back(path); // 将当前路径添加到结果中
            return;
        }

        // 如果当前节点是叶子节点但没有找到合适的路径，直接返回
        if (!cur->left && !cur->right) return;

        // 递归处理左子树
        if (cur->left) {
            path.push_back(cur->left->val); // 将左子节点的值添加到当前路径中
            count -= cur->left->val; // 更新剩余目标和
            traversal(cur->left, count); // 递归遍历左子树
            count += cur->left->val; // 回溯，恢复剩余目标和
            path.pop_back(); // 回溯，移除当前路径中的左子节点值
        }

        // 递归处理右子树
        if (cur->right) {
            path.push_back(cur->right->val); // 将右子节点的值添加到当前路径中
            count -= cur->right->val; // 更新剩余目标和
            traversal(cur->right, count); // 递归遍历右子树
            count += cur->right->val; // 回溯，恢复剩余目标和
            path.pop_back(); // 回溯，移除当前路径中的右子节点值
        }

        return;
    }

public:
    // 主函数，寻找所有从根节点到叶子节点的路径，使得路径上所有节点值的和等于给定值
    vector<vector<int>> pathSum(TreeNode* root, int sum) {
        result.clear(); // 清空结果
        path.clear(); // 清空当前路径
        if (root == NULL) return result; // 如果根节点为空，直接返回空结果
        path.push_back(root->val); // 将根节点值添加到当前路径中
        traversal(root, sum - root->val); // 调用辅助函数，从根节点开始递归遍历
        return result; // 返回所有满足条件的路径
    }
};

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

题目：

根据一棵树的中序遍历与后序遍历构造二叉树。

注意: 你可以假设树中没有重复的元素。

例如，给出

• 中序遍历 inorder = [9,3,15,20,7]
• 后序遍历 postorder = [9,15,7,20,3] 返回如下的二叉树：

思路：

以 后序数组的最后一个元素为切割点，先切中序数组，根据中序数组，反过来再切后序数组。一层一层切下去，每次后序数组最后一个元素就是节点元素。

如果让我们肉眼看两个序列，画一棵二叉树的话，应该分分钟都可以画出来。

流程如图：

• 第一步：如果数组大小为零的话，说明是空节点了。

• 第二步：如果不为空，那么取后序数组最后一个元素作为节点元素。

• 第三步：找到后序数组最后一个元素在中序数组的位置，作为切割点

• 第四步：切割中序数组，切成中序左数组和中序右数组 （顺序别搞反了，一定是先切中序数组）

• 第五步：切割后序数组，切成后序左数组和后序右数组

• 第六步：递归处理左区间和右区间

class Solution {
private:
    TreeNode* traversal(vector<int>& inorder, vector<int>& postorder) {
        // 如果后序遍历数组为空，返回NULL
        if (postorder.size() == 0) return NULL;

        // 后序遍历数组的最后一个元素是当前的根节点值
        int rootValue = postorder[postorder.size() - 1];
        TreeNode* root = new TreeNode(rootValue);

        // 如果只有一个元素，则直接返回当前根节点
        if (postorder.size() == 1) return root;

        // 在中序遍历数组中找到根节点的位置
        int delimiterIndex;
        for (delimiterIndex = 0; delimiterIndex < inorder.size(); delimiterIndex++) {
            if (inorder[delimiterIndex] == rootValue) break;
        }

        // 切割中序遍历数组
        // 左子树的中序遍历数组：[0, delimiterIndex)
        vector<int> leftInorder(inorder.begin(), inorder.begin() + delimiterIndex);
        // 右子树的中序遍历数组：[delimiterIndex + 1, end)
        vector<int> rightInorder(inorder.begin() + delimiterIndex + 1, inorder.end());

        // 去掉后序遍历数组的最后一个元素
        postorder.resize(postorder.size() - 1);

        // 切割后序遍历数组
        // 左子树的后序遍历数组：[0, leftInorder.size)
        vector<int> leftPostorder(postorder.begin(), postorder.begin() + leftInorder.size());
        // 右子树的后序遍历数组：[leftInorder.size(), end)
        vector<int> rightPostorder(postorder.begin() + leftInorder.size(), postorder.end());

        // 递归构建左子树和右子树
        root->left = traversal(leftInorder, leftPostorder);
        root->right = traversal(rightInorder, rightPostorder);

        return root;
    }

public:
    // 主函数，构建二叉树
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        // 如果中序遍历数组或后序遍历数组为空，返回NULL
        if (inorder.size() == 0 || postorder.size() == 0) return NULL;
        // 调用辅助函数构建二叉树
        return traversal(inorder, postorder);
    }
};