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

文档讲解：代码随想录 (programmercarl.com)

视频讲解：代码随想录的个人空间-代码随想录个人主页-哔哩哔哩视频 (bilibili.com)

LeetCode 找树左下角的值

题目链接：513. 找树左下角的值 - 力扣（LeetCode）

解题思路：层序遍历，保存队列第一个值即可。

代码如下：

class Solution {
public:
    int findBottomLeftValue(TreeNode* root) {
        queue<TreeNode*>qe;
        qe.push(root);
        int res;
        while(!qe.empty()){
            int size=qe.size();
            res=qe.front()->val;
            for(int i=0;i<size;i++){
                TreeNode* node=qe.front();
                qe.pop();
                // res=node->val;
                if(node->left)qe.push(node->left);
                if(node->right)qe.push(node->right);
            }
        }
        return res;
    }
};

LeetCode 路径总和 

题目链接：112. 路径总和 - 力扣（LeetCode）

解题思路：回溯

解题代码如下：

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

class Solution {
public:
    void sumpath(TreeNode* root, int targetSum,vector<vector<int>>&res,vector<int>&path){
        if(!root->left&&!root->right&&targetSum==root->val){
            res.push_back(path);
            return;
        }
        if(!root->left&&!root->right)return;
        if(root->left){
            path.push_back(root->left->val);
            sumpath(root->left,targetSum-root->val,res,path);
            path.pop_back();
        }
        if(root->right){
            path.push_back(root->right->val);
            sumpath(root->right,targetSum-root->val,res,path);
            path.pop_back();
        }
    }
    vector<vector<int>> pathSum(TreeNode* root, int targetSum) {
        vector<vector<int>>res;
        vector<int>path;
        if(!root)return res;
        path.push_back(root->val);
        sumpath(root,targetSum,res,path);
        return res;
    }
};

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

题目链接：106. 从中序与后序遍历序列构造二叉树 - 力扣（LeetCode）

解题思路：分割，递归。

解题代码如下：

class Solution {
public:
    TreeNode* buildTree (vector<int>& inorder, vector<int>& postorder){
        if(postorder.size()==0)return nullptr;
        int rootvalue=postorder[postorder.size()-1];
        TreeNode* root=new TreeNode(rootvalue);
        if(postorder.size()==1)return root;
        int inorderindex=0;
        for(;inorderindex<inorder.size();inorderindex++){
            if(inorder[inorderindex]==rootvalue)break;
        }
        vector<int>leftInorder(inorder.begin(),inorder.begin()+inorderindex);
        vector<int>rightInorder(inorder.begin()+inorderindex+1,inorder.end());
        postorder.resize(postorder.size() - 1);
        vector<int>leftPoster(postorder.begin(),postorder.begin()+leftInorder.size());
        vector<int>rightPoster(postorder.begin()+leftInorder.size(),postorder.end());
        root->left=buildTree(leftInorder,leftPoster);
        root->right=buildTree(rightInorder,rightPoster);
        return root;
    }
};

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

题目链接：105. 从前序与中序遍历序列构造二叉树 - 力扣（LeetCode）

解题思路：同上。

实现代码：

class Solution {
public:
    TreeNode* travesal(vector<int>& preorder, vector<int>& inorder,int preorderbegin,int preorderend,int inorderbegin,int inorderend) {
        if(preorderend==preorderbegin)return nullptr;
        int rootvalue=preorder[preorderbegin];
        TreeNode* root=new TreeNode(rootvalue);
        if(preorderend-preorderbegin==1)return root;
        int inorderindex=inorderbegin;
        for(;inorderindex<inorderend;inorderindex++){
            if(inorder[inorderindex]==rootvalue)break;
        }
        int leftinorderbegin=inorderbegin;
        int leftinorderend=inorderindex;
        int rightinorderbegin=inorderindex+1;
        int rightinorderend=inorderend;

        int leftpreorderbegin=preorderbegin+1;
        int leftpreorderend=leftpreorderbegin+(leftinorderend-leftinorderbegin);
        int rightpreorderbegin=leftpreorderend;
        int rightpreorderend=preorderend;
        root->left=travesal(preorder,inorder,leftpreorderbegin,leftpreorderend,leftinorderbegin,leftinorderend);
        root->right=travesal(preorder,inorder,rightpreorderbegin,rightpreorderend,rightinorderbegin,rightinorderend);
        return root;
    }
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        return travesal(preorder,inorder, 0, preorder.size(), 0, inorder.size());
    }
};