c++数据结构学习-二叉树路经总和

1.题目描述

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

 2.思路

该题需要找寻二叉树的路径，该路径需要从上到下来遍历，对于二叉树的遍历可以采用递归的方式，该题对于前、中、后序的遍历方法都可以适用。递归函数的返回值可以为bool类型，参数为节点node和目标值和已遍历的路径和的差count，采用差值来判断相较于累加和目标值判断时间复杂度小，累加每次递归都需要计算路径数组的和。递归函数的结束条件为

 if(node->left==nullptr&&node->right==nullptr&&count==0) return true;//为叶子节点且路径等于目标值
 if(node->left==nullptr&&node->right==nullptr) return false;//为叶子节点，不等于目标值

对于路径的寻找和回撤可以采用回溯，以减少复杂度，回溯条件为节点的子节点是否满足条件

        if(node->left)//路径向左节点走
        {
            count-=node->left->val;//通过将目标值不断减去路径上节点的值来判读路径值得和是否等于目标值，相较于不断求求路径和于目标值比较的方法时间复杂度低
            if(getsum(node->left,count)) return true ;//递归
            count+=node->left->val;//回溯
        }
        if(node->right)
        {
            count-=node->right->val;
            if(getsum(node->right,count)) return true;
            count+=node->right->val;
        }

3.代码

总体代码如下所示

/**
 * 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:
    bool getsum(TreeNode*node,int count)
    {
        if(node->left==nullptr&&node->right==nullptr&&count==0) return true;//为叶子节点且路径等于目标值
        if(node->left==nullptr&&node->right==nullptr) return false;//为叶子节点，不等于目标值

        if(node->left)//路径向左节点走
        {
            count-=node->left->val;//通过将目标值不断减去路径上节点的值来判读路径值得和是否等于目标值，相较于不断求求路径和于目标值比较的方法时间复杂度低
            if(getsum(node->left,count)) return true ;//递归
            count+=node->left->val;//回溯
        }
        if(node->right)
        {
            count-=node->right->val;
            if(getsum(node->right,count)) return true;
            count+=node->right->val;
        }
        return false;//函数需要返回值
    }
    bool hasPathSum(TreeNode* root, int targetSum) {
        if(root==nullptr) return false;
        return getsum(root,targetSum-root->val);
    }
};

4.类似题目

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

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

该题主要不同点是需要找到满足条件的所有路径，因此需要遍历路径，创建路径数组来保存路径，递归函数不需要返回值。

递归结束条件为

        if(node->left==nullptr&&node->right==nullptr&&targetSum==0) //满足条件的路径
            {result.push_back(path);
            return;} 
        if(node->left==nullptr&&node->right==nullptr) return; //不满足条件的路径

 节点的遍历和回溯也需要小改

        if(node->left)
        {
            targetSum-=node->left->val;
            path.push_back(node->left->val);
            getpath(node->left,result,path,targetSum);
            targetSum+=node->left->val;
            path.pop_back();
        }
        if (node->right) { // 右 （空节点不遍历）
            path.push_back(node->right->val);
            targetSum-= node->right->val;
            getpath(node->right,result,path,targetSum);;   // 递归
            targetSum += node->right->val;       // 回溯
            path.pop_back();                // 回溯
        }
    }

整体代码为

/**
 * 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:
    void getpath(TreeNode*node,vector<vector<int>>&result,vector<int>&path,int targetSum)
    {
        if(node->left==nullptr&&node->right==nullptr&&targetSum==0) 
            {result.push_back(path);
            return;} 
        if(node->left==nullptr&&node->right==nullptr) return;      
        if(node->left)
        {
            targetSum-=node->left->val;
            path.push_back(node->left->val);
            getpath(node->left,result,path,targetSum);
            targetSum+=node->left->val;
            path.pop_back();
        }
        if (node->right) { // 右 （空节点不遍历）
            path.push_back(node->right->val);
            targetSum-= node->right->val;
            getpath(node->right,result,path,targetSum);;   // 递归
            targetSum += node->right->val;       // 回溯
            path.pop_back();                // 回溯
        }
    }
    vector<vector<int>> pathSum(TreeNode* root, int targetSum) {
        vector<vector<int>>result;
        vector<int>path;
        if(root==nullptr)return result;
        path.push_back(root->val);
        getpath(root,result,path,targetSum-root->val);
        return result;
    }
};