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

513.找树左下角的值、112.路径总和、113路径之和Ⅱ、106.从中序与后序遍历序列构建二叉树

513.找树左下角的值

对于这道题，我们可以递归着做，首先，我们定义一个全局的深度遍量，如果访问的节点的深度大于这个深度，那么我们认为新访问的节点比以往访问过的都要深，于是认为新节点就是左下角的值，但同时既然要求的是左下角，那么我们必须要先访问左孩子，才能避免被右边的值给抢先。
当然，如果孩子是空节点，那么我们不进行访问，只去访问非空节点。

同时也可以利用层次遍历的方式，层次遍历只需要记录每一行的最左端元素即可，此文不再介绍。

代码

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

112.路径总和

对于路径总和，我们可以定义一个全局变量result，和全局变量宿命，分别用来记录结果和当前的路径和，如果找到了某条路径，我们都向上层返回true。
我们访问一个新节点，将其值加入到sum中。
如果这个节点不是叶子节点，，并且继续向下层访问。
如果节点的左孩子存在，我们访问它的左孩子，如果它的右孩子存在，我们访问它的右孩子。
如果是叶子节点，我们判断当前的sum是否等于目标值，如果等于，就让result=true，如果不等于，我们就让sum减掉这个节点的值，并且返回上一级.

代码

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

113路径之和Ⅱ

与上题相似，我们可以进行递归判断，设计几个全局变量，
① 结果数组，我们可以设计一个数组用来记录所有满足条件的路径
②当前路径，我们口蹄疫设计一个数组用来容纳当前路径，每访问一个节点，我们就将其放入到这个数组中
③目标值，我们将目标值设为一个全局变量，这样子就不用在每个函数一直传送参数（上一个代码就没有这样设计，显得自己很傻）。
④我们记录当前路径节点之和，方便进行比较，如果不设计，则每次访问到叶子节点都需要加一遍，很麻烦。

首先，我们判断给定的节点是否是空的，如果是空的，直接返回空结果。
如果不空，则进入我们的递归判断函数中。
在函数中，
我们先将这个节点放入到我们的当前路径数组中，并让sum加上这个值。
如果这个节点不是叶子，我们就递归访问它的左孩子，或者右孩子（如果存在的话）。
如果是叶子节点，我们判断当前的sum是不是等于了目标值，如果等于，就把路径放入到结果中。
返回上一路径时，我们需要做出回宿操作，让sum减掉当前节点值，让当前路径移除该节点。

class Solution {
public:
vector<vector<int>> result;
vector<int> nownode;
int sum;
int tar;
    void traval(TreeNode * root)
    {
        nownode.push_back(root->val);
        sum +=root->val;
        if(root->left==nullptr&&root->right == nullptr) 
            if(sum==tar) result.push_back(nownode);
        if(root->left) traval(root->left);
        if(root->right) traval(root->right);
        sum-=root->val;
        nownode.pop_back();
    }
    vector<vector<int>> pathSum(TreeNode* root, int targetSum) {
        tar = targetSum;
        if(root==nullptr) return result;
        traval(root);
        return result;
    }
};

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 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 舍弃末尾元素
        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);
    }
};