代码随想录算法训练营第十八天|Leetcode 513.找树左下角的值、112.路径总和、106. 从中序与后序遍历序列构造二叉树

文档讲解：代码随想录

视频讲解：怎么找二叉树的左下角？ 递归中又带回溯了，怎么办？| LeetCode：513.找二叉树左下角的值_哔哩哔哩_bilibili

拿不准的遍历顺序，搞不清的回溯过程，我太难了！ | LeetCode：112. 路径总和_哔哩哔哩_bilibili

坑很多！来看看你掉过几次坑 | LeetCode：106.从中序与后序遍历序列构造二叉树_哔哩哔哩_bilibili

---

第十八天，继续打卡继续冲，紧赶慢赶的，害。

513.找树左下角的值

感受思路：本题用层序更简单，代码模板之前有写。但还是先记录一下递归的用法，先掌握递归。定义两个变量用来记录当前最大深度和最大深度的值，终止条件是如果当前遍历的是叶子节点，我们更新最大深度，并将其值记录下来。然后是按照后序遍历顺序处理左右子树，若存在就递归调用函数并且做一个回溯。因为我们处理完根节点左边后要向上返回去处理右边子树，同时也表示当前叶子节点不一定深度是最深的。

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);
        return result;
    }
};

 再看看层序遍历，明显更合适本题：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
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.路径总和

思路：本题同样用递归，同时没有处理中间顺序的逻辑，因此三种遍历方式可任意。思路就是自上而下遍历，同时每遍历到左孩子将目标值与相应的元素值作差，直到我们遍历到叶子节点时若目标值为0，即说明我们找到了一条符合要求的路径，直接返回true。除此之外，递归后我们需要回溯，也就是处理左子树后我们需要逐层再向上返回true，直到根节点后我们再遍历右子树。要实现这点只需要每次递归目标值作差后再加上减去的元素值即可。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
private:
    bool traversal(TreeNode* node, int count){
        if( node->left == NULL && node->right == NULL && count == 0) return true;
        if( node->left == NULL && node->right == NULL && count != 0) return false;
        if(node->left){
            count -= node->left->val;
            if(traversal(node->left, count)) return true;
            count += node->left->val;
        }
        if(node->right){
            count -= node->right->val;
            if(traversal(node->right, count)) return true;
            count += node->right->val;
        }
        return false;
    }
public:
    bool hasPathSum(TreeNode* root, int targetSum) {
        if(root == NULL) return false;
        return traversal(root, targetSum - root->val);
    }
};

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

思路：想了许久，受限本人水平，那么本题思路个人也是似懂非懂的情况下就直接放出卡哥的讲解思路了，以后回头复习时我肯定会再根据个人理解进行修改。

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

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

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

• 第四步：切割中序数组，切成中序左数组和中序右数组 （顺序别搞反了，一定是先切中序数组）这一步只有先切中序数组，因为已经可以找到它的根节点的位置，然后切后序数组的时候也需要根据中序数组的长度来切割。

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

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

需要注意的是，本题是切割数组，因此也涉及到了循环不变量。即我们在先后切割中序和后序数组时要从一而终的遵循一种原则，那下面代码是遵循的左闭右开原则：

class solution{
private:
    TreeNode* traversal(vector<int>& inorder, vector<int>& postorder){
        if(postorder.size() == 0) return NULL;
        int rootvalue = postorder[postorder.size() - 1];
        TreeNode* root = new TreeNode(rootvalue);
        if(postorder.size() == 1) return root;
        int index;//中序遍历的切割点
        for(index = 0; index < inorder.size(); index++){
            if(inorder[index] == rootvalue) break;
        }
        //切割中序数组，[0, index)
        vector(int) leftinorder(inorder.begin(), inorder.begin() + index);
        [index+1,end)
        vecotr(int) rightinorder(inorder.begin() + index + 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){
        if(inorder.size() == 0 || postorder.size() == 0) return NULL;
        return traversal(inorder, postorder);
    }
};

 总结：二叉树很难，算法很难，简单的事也不值得我们如此煞费苦心、绞尽脑汁不是吗？