代码随想录算法训练营第十五天|路径总和 从中序与后序遍历序列构造二叉树

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
解释:由于树是空的,所以不存在根节点到叶子节点的路径。
class Solution {
public:
    bool dfsorder(TreeNode *cur,int count)
    {
        if(!cur->left && !cur->right&& count == 0) return true;
        if(!cur->left && !cur->right ) return false;

        if(cur->left)
        {
            count -= cur->left->val;
            if(dfsorder(cur->left,count)) return true;
            count += cur->left->val;
        }
        if(cur->right)
        {
            count -= cur->right->val;
            if(dfsorder(cur->right,count)) return true;
            count += cur->right->val;
        }
        return false;        
    }


    bool hasPathSum(TreeNode* root, int targetSum) {
        if(root == NULL) return false;
        int count = targetSum;
        return dfsorder(root,count - 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
输出:[]

class Solution {

    vector<vector<int>> res;
    vector<int> path;
    void dfsorder(TreeNode*cur,int count)
    {
        if(!cur->left && !cur->right && count == 0)
        {
            res.push_back(path);
            return;
        }

        if(!cur->left && !cur->right) return;

        if(cur->left)
        {
            path.push_back(cur->left->val);
            count -= cur->left->val;
            dfsorder(cur->left,count);
            count += cur->left->val;
            path.pop_back();
        }

        if(cur->right)
        {
            path.push_back(cur->right->val);
            count -= cur->right->val;
            dfsorder(cur->right,count);
            count += cur->right->val;
            path.pop_back();
        }
        return;
    }
public:
    vector<vector<int>> pathSum(TreeNode* root, int targetSum) {
        res.clear();
        path.clear();
        if(root == NULL) return res;
        path.push_back(root->val);
        dfsorder(root,targetSum - root->val);
        return res;

    }
};

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]

 简简单单分割字符串

/**
 * 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 {
public:
    TreeNode* inpostbuild(vector<int> in,vector<int> post)
    {
        if(post.size() == 0) return NULL;
        TreeNode* root = new TreeNode(post[post.size() - 1]);
        if(post.size() == 1) return root;

        int delimiter;
        for(delimiter = 0; delimiter < in.size(); delimiter++)
        {
            if(in[delimiter] == post[post.size() - 1]) break;
        }
//分割inorder
        vector<int> leftIn (in.begin(),in.begin() + delimiter);
        vector<int> rightIn (in.begin() + delimiter + 1,in.end());
//分割postorder
        post.resize(post.size() - 1);

        vector<int> leftpost (post.begin(),post.begin() + leftIn.size());
        vector<int> rightpost(post.begin() + leftIn.size(),post.end());

        root->left = inpostbuild(leftIn,leftpost);
        root->right = inpostbuild(rightIn,rightpost);

        return root;

    }


    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        if(postorder.size() == 0) return NULL;
        return inpostbuild(inorder,postorder);
    }
};

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]
/**
 * 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 {
public:
    TreeNode* preinbuild(vector<int> pre,vector<int> in)
    {
        if(in.size() == 0) return NULL;
        TreeNode* root = new TreeNode(pre[0]);
        if(in.size() == 1) return root;

        int divide;
        for(divide = 0; divide < in.size(); divide++)
        {
            if(in[divide] == pre[0]) break;
        }

        vector<int> leftIn(in.begin(),in.begin() + divide);
        vector<int> rightIn(in.begin() + divide + 1,in.end());

        pre.erase(pre.begin());

        vector<int> leftPre(pre.begin() ,pre.begin() + leftIn.size());
        vector<int> rightPre(pre.begin() + leftIn.size(),pre.end());

        root->left = preinbuild(leftPre,leftIn);
        root->right = preinbuild(rightPre,rightIn);
        return root;
    }

    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        if(inorder.size() == 0) return NULL;
        return preinbuild(preorder,inorder);
    }
};

  • 8
    点赞
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值