刷题了：513.找树左下角的值|112. 路径总和| 113. 路径总和ii|106.从中序与后序遍历序列构造二叉树|105.从前序与中序遍历序列构造二叉树

513.找树左下角的值

文章讲解:https://programmercarl.com/0513.%E6%89%BE%E6%A0%91%E5%B7%A6%E4%B8%8B%E8%A7%92%E7%9A%84%E5%80%BC.html
视频讲解:https://www.bilibili.com/video/BV1424y1Z7pn/?spm_id_from=333.1007.top_right_bar_window_history.content.click&vd_source=e70917aa6392827d1ccc8d85e19e8375
题目链接:https://leetcode.cn/problems/find-bottom-left-tree-value/description/
实现情况：
找到深度最大的叶子节点

/**
 * 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 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;
    }
};

112. 路径总和

文章讲解:路径总和
视频讲解:https://www.bilibili.com/video/BV19t4y1L7CR/?spm_id_from=333.788&vd_source=e70917aa6392827d1ccc8d85e19e8375
题目链接:https://leetcode.cn/problems/path-sum/description/
实现情况：

```c
/**
 * 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* cur, int count) {
        if (!cur->left && !cur->right && count == 0)
            return true; 
        if (!cur->left && !cur->right)
            return false; 

        if (cur->left) {             // 左
            count -= cur->left->val; 
            if (traversal(cur->left, count))
                return true;//注意这里
            count += cur->left->val; 
        }
        if (cur->right) {             // 右
            count -= cur->right->val; 
            if (traversal(cur->right, count))
                return true;
            count += cur->right->val;
        }
        return false;
    }

public:
    bool hasPathSum(TreeNode* root, int targetSum) {
        if (!root)
            return false;
        return traversal(root, targetSum - root->val);
    }
};

113. 路径总和ii

题目链接:https://leetcode.cn/problems/path-sum-ii/description/
实现情况：

和112. 路径总和的方法一致，就行需要遍历所以节点，并且记录路径

/**
 * 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:
    vector<vector<int>> result;
    vector<int> path;

    //这里不需要返回值是因为我们需要遍历所有节点
    void traversal(TreeNode* cur, int count){
        if(!cur->right && cur->left==NULL && count==0){
            result.push_back(path);//符合条件的，添加到返回的结果中
            return ;
        }

        if(!cur->right && cur->left == NULL)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 targetSum) {
        result.clear();
        path.clear();
        if(!root) return result;
        path.push_back(root->val);
        traversal(root,targetSum-root->val);
        return result;

    }
};

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

文章讲解:https://programmercarl.com/0106.%E4%BB%8E%E4%B8%AD%E5%BA%8F%E4%B8%8E%E5%90%8E%E5%BA%8F%E9%81%8D%E5%8E%86%E5%BA%8F%E5%88%97%E6%9E%84%E9%80%A0%E4%BA%8C%E5%8F%89%E6%A0%91.html#%E7%AE%97%E6%B3%95%E5%85%AC%E5%BC%80%E8%AF%BE
视频讲解:https://www.bilibili.com/video/BV1vW4y1i7dn/?spm_id_from=333.788&vd_source=e70917aa6392827d1ccc8d85e19e8375
题目链接:https://leetcode.cn/problems/construct-binary-tree-from-inorder-and-postorder-traversal/description/
实现情况：

/**
 * 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:
TreeNode* traversal (vector<int>& inorder, int inorderBegin, int inorderEnd, vector<int>& postorder, int postorderBegin, int postorderEnd) {
            if (postorderBegin == postorderEnd) return NULL;

        int rootValue = postorder[postorderEnd - 1];
        TreeNode* root = new TreeNode(rootValue);

        if (postorderEnd - postorderBegin == 1) return root;

        int delimiterIndex;
        for (delimiterIndex = inorderBegin; delimiterIndex < inorderEnd; delimiterIndex++) {
            if (inorder[delimiterIndex] == rootValue) break;
        }
        // 切割中序数组
        // 左中序区间，左闭右开[leftInorderBegin, leftInorderEnd)
        int leftInorderBegin = inorderBegin;
        int leftInorderEnd = delimiterIndex;
        // 右中序区间，左闭右开[rightInorderBegin, rightInorderEnd)
        int rightInorderBegin = delimiterIndex + 1;
        int rightInorderEnd = inorderEnd;

        // 切割后序数组
        // 左后序区间，左闭右开[leftPostorderBegin, leftPostorderEnd)
        int leftPostorderBegin =  postorderBegin;
        int leftPostorderEnd = postorderBegin + delimiterIndex - inorderBegin; // 终止位置是 需要加上 中序区间的大小size
        // 右后序区间，左闭右开[rightPostorderBegin, rightPostorderEnd)
        int rightPostorderBegin = postorderBegin + (delimiterIndex - inorderBegin);
        int rightPostorderEnd = postorderEnd - 1; // 排除最后一个元素，已经作为节点了

        root->left = traversal(inorder, leftInorderBegin, leftInorderEnd,  postorder, leftPostorderBegin, leftPostorderEnd);
        root->right = traversal(inorder, rightInorderBegin, rightInorderEnd, postorder, rightPostorderBegin, rightPostorderEnd);

        return root;
    }

public:
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        if (inorder.size() == 0 || postorder.size() == 0)
            return NULL;
        return traversal(inorder, 0, inorder.size(), postorder, 0, postorder.size());
    }
};

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

题目链接:https://leetcode.cn/problems/construct-binary-tree-from-preorder-and-inorder-traversal/description/
实现情况：

/**
 * 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:
    TreeNode* traversal(vector<int>& inorder, int inorderBrgin, int inorderEnd,
                        vector<int>& preorder, int preorderBegin,
                        int preorderEnd) {
        if (preorderBegin == preorderEnd)
            return NULL; //

        // 获取根节点
        int rootValue = preorder[preorderBegin];
        TreeNode* root = new TreeNode(rootValue);

        if (preorderEnd - preorderBegin == 1)
            return root; // 前序，如果只有一个 那这个就是根节点

        int delimiterIndex; // 在中序中找到根节点
        for (delimiterIndex = inorderBrgin; delimiterIndex < inorderEnd;
             delimiterIndex++) {
            if (inorder[delimiterIndex] == rootValue)
                break;
        }

        // 分割中序数组
        // 中序左区间 [leftInorderBegin,leftInorderEnd);
        int leftInorderBegin = inorderBrgin;
        int leftInorderEnd = delimiterIndex;
        //[rightInorderBegin, rightInorderEnd)
        int rightInorderBegin = delimiterIndex + 1;
        int rightInorderEnd = inorderEnd;

    

        // 切割前序数组
        //[leftPreorderBegin, leftPreorderEnd)
        //delimiterIndex - inorderBrgin= 中序左区间的长度
        int leftPreorderBegin = preorderBegin + 1;
        int leftPreorderEnd = preorderBegin + 1 + delimiterIndex - inorderBrgin;

        //[rightPreorderBegin, rightPreorderEnd)
        int rightPreorderBegin =
            preorderBegin + 1 + (delimiterIndex - inorderBrgin);
        int rightPreorderEnd = preorderEnd;

        root->left = traversal(inorder, leftInorderBegin, leftInorderEnd,
                               preorder, leftPreorderBegin, leftPreorderEnd);
        root->right = traversal(inorder, rightInorderBegin, rightInorderEnd,
                                preorder, rightPreorderBegin, rightPreorderEnd);

        return root;
    }

public:
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        if (!inorder.size() || preorder.size() == 0)
            return NULL;
        return traversal(inorder, 0, inorder.size(), preorder, 0,
                         preorder.size());
    }
};

总结

注意理解回溯的使用，牢记遍历的顺序和需求