二叉树从根结点到叶结点系列

打印所有从根节点到叶节点的所有路径

算法思想：

1. 访问的当前结点为空时，直接退出当前函数
2. 访问的当前结点不空时，都将当前结点值存入数组。当前结点为叶结点时，就直接输出当前的数组。当前结点为内部结点时，直接递归地调用函数，访问下层结点

注：$path$表示访问当前结点时，传入函数的数组

#include<iostream>
#include<vector>

using namespace std;

struct TreeNode {
    
    
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {
    
    }
};

void getPath(TreeNode* root, vector<int> path){
    
    
    if(root == nullptr){
    
    
        return ;
    }
    path.push_back(root->val);
    if(root->left == nullptr && root->right == nullptr){
    
    
        for(int val : path){
    
    
            cout<<val<<" ";
        }
        cout<<endl;
    }
    getPath(root->left, path);
    getPath(root->right, path);
}

int main(){
    
    
    TreeNode* root = new TreeNode(1);
    vector<int> path;
    getPath(root, path);
    return 0;
}

判断二叉树是否存在从根结点到叶结点的路径，使得该路径结点值之和等于sum

方法一：将上层结点的值累加到下层结点，最后判断叶结点的值是否和$sum$相等

bool hasPathSum(TreeNode* root, int sum) {
    
    
        if(root == nullptr){
    
    
            return false;
        }
        if(root->left == nullptr && root->right == nullptr){
    
    
            return root->val == sum;//叶结点时判断
        }
        if(root->left != nullptr){
    
    
            root->left->val += root->val;
        }
        if(root->right != nullptr){
    
    
            root->right->val += root->val;
        }
        return hasPathSum(root->left, sum) || hasPathSum(root->right, sum);
    }

方法二：不修改二叉树

注：其中$sum$表示访问当前结点时，递归函数接收的参数。$true$指的是访问某结点时函数的返回值，一旦有一个结点返回$true$，函数调用栈最底层函数一定返回$true$。

bool hasPathSum(TreeNode* root, int sum){
    
    
    if(root == nullptr){
    
    
    	//进入这个if一定是因为某内部节点只有一个孩子，空孩子调用的函数进入这个if
    	//此时没有到达叶结点，无需比较sum，直接返回false
    	//只有到达叶结点，才需要比较sum
        return false;
    }
    if(root->left == nullptr && root->right == nullptr){
    
    
        return sum - root->val == 0;
    }
    return hasPathSum(root->left, sum - root->val) || hasPathSum(root->right, sum - root->val);
}

参考题解：狗大王

求根到叶结点数字之和

有了上面将父结点的值累加到子结点的思路，我们很容易求出根到叶结点的数字之和

算法思想：

1. 当前结点有孩子结点，将当前结点的值乘10后，加到子结点
2. 当前结点是叶子结点（此时叶节点已经记录了从根到叶结点的路径代表的数字），将当前结点的值累加到$sum$
3. 当前结点为空，结束当前函数，返回调用处

class Solution {
    
    
public:
    int sum = 0;

    int sumNumbers(TreeNode* root) {
    
    
        if(root == nullptr){
    
    
            return 0;
        }
        if(root->left != nullptr){
    
    
            root->left->val += 10 * root->val;
        }
        if(root->right != nullptr){
    
    
            root->right->val += 10 * root->val;
        }
        if(root->left == nullptr && root->right == nullptr){
    
    
            sum += root->val;
        }
        sumNumbers(root->left);
        sumNumbers(root->right);
        return sum;
    }
};