本文已参与「新人创作礼」活动，一起开启掘金创作之路。

题目描述

给定一个二叉树root和一个值 sum ，判断是否有从根节点到叶子节点的节点值之和等于 sum 的路径。

1. 该题路径定义为从树的根结点开始往下一直到叶子结点所经过的结点
2. 叶子节点是指没有子节点的节点
3. 路径只能从父节点到子节点，不能从子节点到父节点
4. 总节点数目为n

数据范围：

1. 树上的节点数满足 0 ≤ n ≤ 10000
2. 每个节点的值都满足∣val∣≤1000

---

解题思路

二叉树的简单题，思考两个情景即可：叶子节点与非叶子节点，单独摘出叶子节点的判断逻辑，即左右子树为空并且与期望值相等，即存在一条路径，返回true即可。否则就是非叶子节点，在左右子树中寻找能和自己拼成希望数值的节点。

代码实现1：递归版

// 递归1：简洁版，其中也包含了回溯
bool hasPathSum1(TreeNode* root, int sum) {
    if (!root)    return false;
    if (root->val == sum && !root->left && !root->right)    return true;
    return hasPathSum(root->left, sum - root->val) || 
    	hasPathSum(root->right, sum - root->val);
}

// 递归2：回溯版
bool traversal(TreeNode* root, int targetSum) {

    if (!root->left && !root->right && targetSum - root->val == 0) {
        return true;
    }
    bool left = false;
    bool right = false;
    if (root->left) {
        left = traversal(root->left, targetSum - root->val);
        if (left)   return true;
    }

    if (root->right) {
        right = traversal(root->right, targetSum - root->val);
        if (right)  return true;
    }

    return false;
}

bool hasPathSum2(TreeNode* root, int targetSum) {
    if (!root)  return false;
    return traversal(root, targetSum);
}

代码实现2：迭代法

解法引用自代码随想录

bool haspathsum(treenode* root, int sum) {
	if (root == null) return false;
	
	// 此时栈里要放的是pair<节点指针，路径数值>
	stack<pair<treenode*, int>> st;
	st.push(pair<treenode*, int>(root, root->val));
	
	while (!st.empty()) {
	    pair<treenode*, int> node = st.top();
	    st.pop();
	    
	    // 如果该节点是叶子节点了，同时该节点的路径数值等于sum，那么就返回true
	    if (!node.first->left && !node.first->right && sum == node.second) return true;
	
	    // 右节点，压进去一个节点的时候，将该节点的路径数值也记录下来
	    if (node.first->right) {
	        st.push(pair<treenode*, int>(node.first->right, node.second + node.first->right->val));
	    }
	
	    // 左节点，压进去一个节点的时候，将该节点的路径数值也记录下来
	    if (node.first->left) {
	        st.push(pair<treenode*, int>(node.first->left, node.second + node.first->left->val));
	    }
	}
	return false;
}

---

💡进阶：打印出每一条合法路径

解题思路

DFS + 回溯思想，走到那个节点就加入path，进行深度优先搜索，存在合法路径就向大数组中存放此路径，不存在就回溯节点。

代码实现

class Solution {
private:
    vector<vector<int>> ret;
    vector<int> path;

public:
    void DFS(TreeNode* root,int expectNumber) {
        if (!root)    return;
        
        expectNumber -= root->val;
        path.push_back(root->val);
        
        //叶子节点单独处理
        if (expectNumber == 0 && !root->left && !root->right) {
            ret.push_back(path);
        }
        
        DFS(root->left, expectNumber);
        DFS(root->right, expectNumber);
        path.pop_back();
        
    }
    vector<vector<int>> FindPath(TreeNode* root,int expectNumber) {
        DFS(root, expectNumber);
        return ret;
    }
};

---

💡延申：计算合法路径个数

给定的一个二叉树root和一个整数值 sum ，求该树有多少路径的的节点值之和等于 sum 。

1. 该题路径定义不需要从根节点开始，也不需要在叶子节点结束，但是一定是从父亲节点往下到孩子节点
2. 总节点数目为n
3. 保证最后返回的路径个数在整形范围内(即路径个数小于2^31^-1

假如二叉树root为{1,2,3,4,5,4,3,#,#,-1}，sum=6，有3条路径符合要求，return 3即可。

解题思路

• 这里规定了不需要到叶子节点，所以在DFS函数中，当节点值与目标值相等，即root->val == sum时，就不需要返回了，而是继续向下找（万一其子树加和为0，也满足条件）。
• 因为也不需要从整棵树的父节点开始计算，那么实现函数也需要向下递归了，即FindPath函数继续传入左右子树，向下搜索寻找满足条件的情况，最终返回统计数即可。

代码实现

int count = 0;
void DFS(TreeNode* root, int sum) {
    if (!root)    return;
    if (root->val == sum)    count++;
    DFS(root->left, sum - root->val);
    DFS(root->right, sum - root->val);
}
int FindPath(TreeNode* root, int sum) {
    if (!root)    return count;
    DFS(root, sum);
    FindPath(root->left, sum);
    FindPath(root->right, sum);
    return count;
}