letcode 分类练习 513.找树左下角的值 112. 路径总和 106.从中序与后序遍历序列构造二叉树

513.找树左下角的值

遍历二叉树，并记录当前的深度，如果深度大于最大深度，那么更新该节点，为了保证是最左的，我们规定顺序一定是先遍历左孩子再遍历右孩子

class Solution {
public:
    int depth = 0;
    int result;
    void getV(TreeNode* root, int d){
        if(!root) return;
        if(!root->left && !root -> right){
            if(d > depth){depth = d; result = root -> val;}
        }
        getV(root -> left, d+1);
        getV(root -> right, d+1);
    }
    int findBottomLeftValue(TreeNode* root) {
        getV(root, 1);
        return result;

    }
};

112. 路径总和

还是对树进行一个dfs遍历，如果当前遍历的节点是叶子节点，就判断当前累计的sum是不是target

class Solution {
public:
    bool find = false;
    void dfs(TreeNode* root, int sum,int targetSum){
        if(!root) return;
        if(sum  == targetSum && !root->left && !root->right){find = true; return;}
        
        if(root->left)dfs(root->left, sum + root -> left -> val, targetSum);
        if(root->right)dfs(root->right, sum + root -> right -> val, targetSum);
    }
    bool hasPathSum(TreeNode* root, int targetSum) {
        if(!root)return false;
        dfs(root, root -> val, targetSum);
        return find;
    }
};

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

这道题有意思，我们做题的时候构造二叉树都是先找后序序列的最后一个元素是根，然后根据这个根切割中序序列，然后再找中序序列前后两个分割序列，注意我们得到了中序分割的左右子树序列，那么我们可以这个左右子树序列的长度再对后序数组进行一个分割：
积累一个vector查询的方式：

// 这个查询是[)区间左闭右开
auto y = find(inorder.begin()+in_left, inorder.begin() + in_right + 1, val);
int index = distance(inorder.begin(), y);

总代码如下：

class Solution {
public:
    TreeNode* build(vector<int>& inorder, vector<int>& postorder, int in_left, int in_right, int po_left,int po_right){
        if(in_left > in_right || po_left > po_right) return nullptr;
        int val = postorder[po_right];
        auto y = find(inorder.begin()+in_left, inorder.begin() + in_right + 1, val);
        int index = distance(inorder.begin(), y);
        int left_length = index - in_left;
        int right_length = in_right - index;
        TreeNode* n = new TreeNode(postorder[po_right]);
        n -> left = build(inorder, postorder, in_left, in_left + left_length -1, po_left, po_left + left_length -1);
        n->right = build(inorder, postorder, in_right - right_length + 1 , in_right, po_right - 1 - right_length + 1, po_right - 1);
        return n;
    }
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        if(inorder.size() == 0) return nullptr;
        return build(inorder, postorder, 0, inorder.size()-1, 0, postorder.size()-1);
    }
};