给出一个二叉树,用一个函数确定是否有一条从根节点到叶子节点的

	bool hasPathSum(TreeNode *root, intsum) {



	 



	    if(root == NULL)



	 



	        return false;



	 



	    if(root->val == sum)



	 



	        return true;



	 



	    return (hasPathSum(root->left, sum-root->val) ||



	 



	            hasPathSum(root->right, sum-root->val));



	 



	}

python解法如下：

def hasPathSum(root, sum):
    if not root:
        return False
    sum -= root.val
    if sum == 0 and root.left is None and root.right is None:
        return True
    return hasPathSum(root.left, sum) or hasPathSum(root.right, sum)

//这或许是最短的代码了吧？
bool hasPathSum(TreeNode* root, int sum) {
    if (nullptr == root) return sum == 0;
    return hasPathSum(root->left, sum - root->val) || hasPathSum(root->right, sum - root->val);
}

//稍微修改了下flxyq的答案，另外也没必要像高票答案那么繁琐
bool hasPathSum(TreeNode *root, int sum) {        
         if(nullptr == root || sum < 0)        
             return false;
    
         if(root->left == nullptr && root->right == nullptr && sum-root->val==0)        
             return true;  
    
         return hasPathSum(root->left,sum-root->val) || hasPathSum(root->right,sum-root->right);        
         } 

	bool hasPathSum(TreeNode *root, intsum) {



	    if( root == NULL && sum != 0 ) return false; // 二叉树的值有正有负吗？



	    if(sum == 0) return true;



	    else return hasPathSum(root->left, sum - root->val) || hasPathSum(root->right, sum - root->val);



	}

bool hasPathSum(TreeNode *root, int sum) {
    TreeNode *p=root;
    if(p->left==NULL&&p-right==NULL)    
    {
        if(p->val==sum)
            return true;
        else
            return false;
    }
    if((p->left!=NULL)&&hasPathSum(p->left,sum-p->val))
        return true;
    else if((p->right!=NULL)&&hasPathSum(p->right,sum-p->val))
        return true;
    else
        return false;
    
}

//剑指offer原题
//注意是根结点到叶子结点，不要把情况想复杂了。
bool hasPathSum（TreeNode *root，int sum）
{ 
   vector<int> vec;            //表示单条路径
   vector<vector<int> > trace;   //所有满足条件的路径和的集合
   int currentSum=0;      //路径和，初始为0
   hasPathCore(root,vec,trace,currentSum,sum);
   if(trace.empty())   //如果trace为空，说明没有满足条件的路径
       return false;
   else
       return true;
}
 
void hasPathCore(TreeNode *root,vector<int> &vec,vector<vector<int> > &trace,int currentSum,int sum)
{
   if(root==NULL)
        return;
   currentSum+=root->val;
   vec.push_back(root->val);
   bool flag=((root->left==NULL)&&(root->right==NULL));
   if(currentSum==sum&&flag)
        trace.push_back(vec);
   if(root->left!=NULL)
        hasPathCore(root->left,vec,trace,currentSum,sum);  
   if(root->right!=NULL)
        hasPathCore(root->right,vec,trace,currentSum,sum);
   vec.pop_back();
 }

bool hasPathSum(TreeNode *root, int sum) {
if(root->val==sum) return true;
if(root->left!=NULL) {
hasPathSum(root->left,sum-root->val);
}
if(root->right!=NULL){
hasPathSum(root->right,sum-root->val);
}
return false;
}

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

bool hasPathSum(TreeNode* root, int sum) {
        if(root == NULL) {
            return false;
        }
        if(root->val == sum && root->left == NULL & root->right ==NULL) {
            return true;
        }
        return hasPathSum(root->left, sum - root->val) || hasPathSum(root->right, sum - root->val);
    }

def hasPathSum(root, int sum):
    if not root or root.val>sum:
        return False
    if root.val==sum:
        return True
    return hasPathSum(root.left,sum-root.val) and hasPathSum(root.right,sum-root.val) 

class Solution {
private:
    vector<vector<int> > result;
    void findnode(TreeNode *root, const int expectNumber,int sum,vector<int> &path)
    {
        if (root == NULL)

        {
            return;
        }

            path.push_back(root->val);
            sum += root->val;

            if (!root->left && !root->right && sum == expectNumber)
            {
                result.push_back(path);
            }
            else {
                findnode(root->left,expectNumber,sum,path);
                findnode(root->right,expectNumber,sum,path);
            }
            path.pop_back();
            sum -= root->val;
    }
public:
    vector<vector<int> > FindPath(TreeNode* root, int expectNumber)
    {
        vector<int> path;
        findnode(root,expectNumber,0,path);
        return result;
    }
};