代码随想录算法训练营第十八天|513. 找树左下角的值,112. 路径总和,106. 从中序与后序遍历序列构造二叉树,105. 从前序与中序遍历序列构造二叉树-优快云博客

本文链接：https://blog.youkuaiyun.com/dragonccl/article/details/132247341

给定一个二叉树的 根节点 root，请找出该二叉树的 最底层最左边 节点的值。

假设二叉树中至少有一个节点。

示例 1:

输入: root = [2,1,3]
输出: 1

示例 2:

输入: [1,2,3,4,null,5,6,null,null,7]
输出: 7

提示:

二叉树的节点个数的范围是 [1,104]
-231 <= Node.val <= 231 - 1

做这道题时，脑子里要想到如何先遍历左边代码：

一直想左叶子递归，就会使得到达新的一层的时候，先访问最左边的；

由此我们也可以想到如果是记录最右边的，就把便利顺序换换就可以解决了

/**
 * 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 {
    int ans;int h;
    void pretravel(TreeNode* r,int height){
        if(r==nullptr)return ;
        if(!r->left&&!r->right){
            if(height>h){
                ans=r->val;
                h=height;
            }
        }
        pretravel(r->left,height+1);
        pretravel(r->right,height+1);
    }
public:
    int findBottomLeftValue(TreeNode* root) {
        h=0;
        pretravel(root,1);
        return ans;
    }
};

112. 路径总和

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

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

示例 1：

输入：root = [5,4,8,11,null,13,4,7,2,null,null,null,1], targetSum = 22
输出：true
解释：等于目标和的根节点到叶节点路径如上图所示。

示例 2：

输入：root = [1,2,3], targetSum = 5
输出：false
解释：树中存在两条根节点到叶子节点的路径：
(1 --> 2): 和为 3
(1 --> 3): 和为 4
不存在 sum = 5 的根节点到叶子节点的路径。

示例 3：

输入：root = [], targetSum = 0
输出：false
解释：由于树是空的，所以不存在根节点到叶子节点的路径。

提示：

树中节点的数目在范围 [0, 5000] 内
-1000 <= Node.val <= 1000
-1000 <= targetSum <= 1000

这里是我使用没有返回值的递归，我把全部轨迹都记录了

/**
 * 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 {
    bool flag;
    void preTravel(TreeNode* r,vector<int>&path,int target){
        path.push_back(r->val);
        if(!r->left&&!r->right){
            int sum=0;
            for(int i=0;i<path.size();i++){
                sum+=path[i];
            }
            if(sum==target){
                flag=true;
            }
        }
        if(r->left){
            preTravel(r->left,path,target);
            path.pop_back();
        }
        if(r->right){
            preTravel(r->right,path,target);
            path.pop_back();
        }
    }
public:
    bool hasPathSum(TreeNode* root, int targetSum) {
        if(root==nullptr)return false;
        flag=false;
        vector<int> ve;
        preTravel(root,ve,targetSum);
        return flag;
    }
};

代返回值的递归：（这个要更难一些，因为我们必须要弄清所有的情况，来定对应返回值）

/**
 * 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 {
    bool preTravel(TreeNode *r,int count){
        if(!r->left&&!r->right&&!count)return true;
        if(!r->left&&!r->right)return false;
        if(r->left){
            if(preTravel(r->left,count-r->left->val))return true;
        }
        if(r->right){
            if(preTravel(r->right,count-r->right->val))return true;
        }
        return false;
    }
public:
    bool hasPathSum(TreeNode* root, int targetSum) {
        if(root==nullptr)return false;
        return preTravel(root,targetSum-root->val);
    }
};

113. 路径总和 II

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

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

示例 1：

输入：root = [5,4,8,11,null,13,4,7,2,null,null,5,1], targetSum = 22
输出：[[5,4,11,2],[5,8,4,5]]

示例 2：

输入：root = [1,2,3], targetSum = 5
输出：[]

示例 3：

输入：root = [1,2], targetSum = 0
输出：[]

提示：

树中节点总数在范围 [0, 5000] 内
-1000 <= Node.val <= 1000
-1000 <= targetSum <= 1000

/**
 * 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 {
    void preTravel(TreeNode *r,int targetSum,vector<int> path,vector<vector<int>> &ans){
        path.push_back(r->val);
        if(!r->left&&!r->right){
            int sum=0;
            for(int i=0;i<path.size();i++){
                sum+=path[i];
            }
            if(sum==targetSum)ans.push_back(path);
        }
        if(r->left){
            preTravel(r->left,targetSum,path,ans);
        }
        if(r->right){
            preTravel(r->right,targetSum,path,ans);
        }
    }
public:
    vector<vector<int>> pathSum(TreeNode* root, int targetSum) {
        vector<vector<int>> ans;
        vector<int> ve;
        if(root==nullptr)return ans;
        preTravel(root,targetSum,ve,ans);
        return ans;
    }
};

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

给定两个整数数组 inorder 和 postorder ，其中 inorder 是二叉树的中序遍历， postorder 是同一棵树的后序遍历，请你构造并返回这颗 二叉树 。

示例 1:

输入：inorder = [9,3,15,20,7], postorder = [9,15,7,20,3]
输出：[3,9,20,null,null,15,7]

示例 2:

输入：inorder = [-1], postorder = [-1]
输出：[-1]

提示:

1 <= inorder.length <= 3000
postorder.length == inorder.length
-3000 <= inorder[i], postorder[i] <= 3000
inorder 和 postorder 都由不同的值组成
postorder 中每一个值都在 inorder 中
inorder 保证是树的中序遍历
postorder 保证是树的后序遍历

/**
 * 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 {
    TreeNode* build(vector<int> inorder,int start1,int end1,vector<int> postorder,int start2,int end2){
        if(start1>end1||start2>end2)return nullptr;
        TreeNode *root=new TreeNode(postorder[end2]);
        int p=start1;
        while(inorder[p]!=postorder[end2])p++;
        int length=end1-p;
        root->left=build(inorder,start1,p-1,postorder,start2,end2-1-length);
        root->right=build(inorder,p+1,end1,postorder,start2+p-start1,end2-1);
        return root;
    }
public:
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        if(inorder.size()==0)return nullptr;
        TreeNode* root= build(inorder,0,inorder.size()-1,postorder,0,postorder.size()-1);
        return root;
    }
};

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

给定两个整数数组 preorder 和 inorder ，其中 preorder 是二叉树的先序遍历， inorder 是同一棵树的中序遍历，请构造二叉树并返回其根节点。

示例 1:

输入: preorder = [3,9,20,15,7], inorder = [9,3,15,20,7]
输出: [3,9,20,null,null,15,7]

示例 2:

输入: preorder = [-1], inorder = [-1]
输出: [-1]

提示:

1 <= preorder.length <= 3000
inorder.length == preorder.length
-3000 <= preorder[i], inorder[i] <= 3000
preorder 和 inorder 均 无重复 元素
inorder 均出现在 preorder
preorder 保证为二叉树的前序遍历序列
inorder 保证为二叉树的中序遍历序列

/**
 * 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 {
    TreeNode* build(vector<int>preorder,int start1,int end1,vector<int>inorder,int start2,int end2){
        if(start1>end1||start2>end2)return nullptr;
        TreeNode *root=new TreeNode(preorder[start1]);
        int p=start2;
        while(inorder[p]!=preorder[start1])p++;
        int length=p-start2;
        root->left=build(preorder,start1+1,start1+1+length-1,inorder,start2,p-1);
        root->right=build(preorder,start1+1+length,end1,inorder,p+1,end2);
        return root;
    }
public:
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        if(preorder.size()==0)return nullptr;
        TreeNode *root=build(preorder,0,preorder.size()-1,inorder,0,inorder.size()-1);
        return root;
    }
};