二叉树路径和-函数是否有返回值

二叉树路径和-函数是否有返回值

one：给定二叉树和一个目标和,判断该树中是否存在根节点到叶子节点的路径,这条路径上所有节点值相加等于目标和。
说明:叶子节点是指没有子节点的节点。

two：给定一个二叉树和一个目标和，找到所有从根节点到叶子节点路径总和等于给定目标和的路径。
说明: 叶子节点是指没有子节点的节点

分析：全局遍历不能有返回值，局部搜索需要返回值

#include "_myPrint.cpp"
#include "stack"
#include "queue"
using namespace std;

// One 二叉树中是否有路径之和为指定值
// Two 二叉树中所有和为指定值的路径
// 注意：写法1和写法2是等同的，都是回溯；写法3会首先改变count的值再作为参数传入，是不正确的
//        // 写法1
//        count -= root -> left -> val;
//        g(count);
//        count += root -> left -> val;
//        // 写法2
//        g(count - root -> left -> val);
//        // 写法3
//        g(count -= root -> left -> val);
class Solution{
private:
    // 寻找和为指定值的所有路径
    vector<vector<int>> res;
    vector<int> path;
    void pathSum2(TreeNode* root, int count){
        if (!root -> left && !root -> right && count == 0){
            res.push_back(path);
            return; // void 函数的return不会对全局变量产生影响
        }
        if (!root -> left && !root -> right) return;
        if (root -> left){
            // 这里path是一个容器 不好直接操作作为参数传入函数 必须改变他的内容 所以使用传统的回溯写法
            path.push_back(root -> left -> val);
            pathSum2(root -> left, count - root -> left -> val); // traceback
            path.pop_back(); // trackback
        }
        if (root -> right){
            path.push_back(root -> right -> val);
            pathSum2(root -> right, count - root -> right -> val);
            path.pop_back();
        }
        return;
    }

public:
    // 是否存在路径和为指定值
    bool pathSum1(TreeNode* root, int count){
        // 前序遍历 + 回溯
        // 遇到叶子节点 并且找到了
        if (!root -> left && !root -> right && count == 0) return true;
        // 到叶子节点 但是和不满足
        if (!root -> left && !root -> right) return false;
        if (root -> left){
            if (pathSum1(root -> left, count - root -> left -> val)) return true; // 这里的true就是bool类型返回值 返回给上层
        }
        if (root -> right){
            if (pathSum1(root -> right, count - root -> right -> val)) return true;
        }
        return false;
    }
    bool hasPathSum(TreeNode* root, int sum){
        if (!root) return false;
        return pathSum1(root, sum - root -> val);
    }

    vector<vector<int>> allPath(TreeNode* root, int sum){
        // 每次运行需要清空
        res.clear();
        path.clear();
        if (!root) return res;
        path.push_back(root -> val);
        pathSum2(root, sum - root -> val);
        return res;
    }
};

int main(){
    Solution s;
    TreeNode* root = new TreeNode(8);
    TreeNode* l = new TreeNode(6);
    TreeNode* r = new TreeNode(7);
    TreeNode* lr = new TreeNode(9);
    TreeNode* rl = new TreeNode(10);

    root->left = l;
    root->right = r;
    l->right = lr;
    r->left=rl;
    vector<vector<int>> res = s.allPath(root, 23);
    printCollection p;
    p.printVecVec(res);

}