【代码随想录算法训练营14期】-Day18 第六章 二叉树 part05

今日内容

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

513.找树左下角的值

1.解题思路

该题目找最底层最左边的节点值，即最后一层的最左边看见的节点（有可能右节点）
递归法：递归length记录节点的高度，reslength记录结果以及结果高度。

2.代码

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

112. 路径总和

给你二叉树的根节点 root 和一个表示目标和的整数 targetSum 。判断该树中是否存在 根节点到叶子节点 的路径，这条路径上所有节点值相加等于目标和 targetSum 。如果存在，返回 true ；否则，返回 false 。
叶子节点 是指没有子节点的节点。

解题思路

这个问题是求解是否一条存在根节点到叶子节点的路径总和等于目标值
解题思路是使用递归法计算所有路径根节点到叶子节点的和，存入sums数组中，然后判断目标值是否在sums数组中。
注意判断树为空特殊情况

代码

class Solution {
public:
    void allPathSum(TreeNode* root, int ans,vector<int>& sums){
        ans += root->val;
        if(root->left == NULL && root->right == NULL){
            sums.push_back(ans);
            return;
        }
        else{
            if(root->left)
                allPathSum(root->left,ans,sums);
            if(root->right)
                allPathSum(root->right,ans,sums);
        }
    }
    bool hasPathSum(TreeNode* root, int targetSum) {
        if(!root) return 0;
        vector<int> sums;
        allPathSum(root,0,sums);
        for(int s : sums){
            if(s == targetSum)
                return true;
        }
        return false;
    }
};

113.路径总和ii

给你二叉树的根节点 root 和一个整数目标和 targetSum ，找出所有 从根节点到叶子节点 路径总和等于给定目标和的路径。

叶子节点 是指没有子节点的节点。

1.解题思路

这个题需要记录路径，则使用数组存下路径值，遇到叶子节点即判断sum是不是等于目标值，如果是，存入ans。

2.代码

class Solution {
public:
    void getPath(TreeNode* root,int targetSum,vector<int> path,vector<vector<int>>& allpath){
        path.push_back(root->val);
        if(root->left == NULL && root->right == NULL){
            int sum = 0;
            for(int p:path){
                sum += p;
            }
            if(sum == targetSum)
                allpath.push_back(path);
            return;
        }
        else{
            if(root->left) getPath(root->left,targetSum,path,allpath);
            if(root->right) getPath(root->right,targetSum,path,allpath);
        }
    }
    vector<vector<int>> pathSum(TreeNode* root, int targetSum) {
        vector<vector<int>> ans;
        if(!root) return ans;
        vector<int> path;
        getPath(root,targetSum,path,ans);
        return ans;
    }
};

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

1.解题思路

思路简单，即后序遍历的最后数一定为该数组的根节点值，根据确定的值在中序遍历中查找其下标i，在根据下标i对中序遍历分割中序左右数组，根据中序左右数组的size来分割后序左右数组，然后对左右子树递归分割建立二叉树。
需要注意的一点，根节点下标为i，每次中序数组分割时，注意右中序子树是从根节点下一个节点开始即begin() + i + 1；

2.代码

class Solution {
public:
    TreeNode* traver (vector<int>& inorder, vector<int>& postorder){
        if(postorder.size() == 0) return NULL;
        //根节点
        int rootval = postorder[postorder.size() - 1];
        //建立根节点
        TreeNode* root = new TreeNode(rootval);
        //如果只有一个根节点不需要分割
        if(postorder.size() == 1) return root;
        //在中序遍历查找根结点位置
        int i = 0;
        for(; i < inorder.size(); i++){
            if(inorder[i] == rootval) break;
        }
        //中序遍历分割点i  不包含begin()+i
        vector<int> leftIn(inorder.begin(),inorder.begin() + i);
        //因为根节点位置位begin()+1,起始点加一
        vector<int> rightIn(inorder.begin() + i + 1, inorder.end());
        //后序遍历分割
        vector<int> leftPost(postorder.begin(),postorder.begin()+leftIn.size());
        vector<int> rightPost(postorder.begin()+leftIn.size(),postorder.end()-1);
        //递归左右子树
        root->left = traver(leftIn,leftPost);
        root->right = traver(rightIn,rightPost);
        return root;
    }
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        if(inorder.size() == 0 || postorder.size() == 0) return NULL;
        return traver(inorder,postorder);
    }
};

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

1.解题思路

前序数组第一个节点即为根节点，然后同理分割数组，递归

2.代码

class Solution {
public:
    TreeNode* travel(vector<int>& preorder, vector<int>& inorder){
        if(preorder.size() == 0) return NULL;
        int rootval = preorder[0];
        TreeNode* root = new TreeNode(rootval);
        if(preorder.size() == 1) return root;
        int i = 0;
        for(; i < inorder.size(); i++){
            if(inorder[i] == rootval) break;
        }
        vector<int> leftIn(inorder.begin(), inorder.begin() + i);
        vector<int> rightIn(inorder.begin() + i + 1, inorder.end());
        vector<int> leftPre(preorder.begin() + 1, preorder.begin() + leftIn.size() + 1);
        vector<int> rightPre(preorder.begin() + leftIn.size() + 1, preorder.end());
        root->left = travel(leftPre,leftIn);
        root->right = travel(rightPre,rightIn);
        return root;
    }
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        if(preorder.size() == 0 || inorder.size() == 0) return NULL;
        return travel(preorder,inorder);
    }
};

总结

• 查找最左下角的值，第一次理解到遍历全局变量，则引用地址&
• 路径总是在递归查找叶节点
• 前序遍历中序遍历分割时创建数组使用 rightPre(preorder.begin() + leftIn.size() + 1, preorder.end());