LeetCode-笔记-112、路径总和

LeetCode-笔记-112、路径总和

112. 路径总和

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

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

1、思路一、深度优先遍历：DFS

就是从根节点出发，往下依次遍历每个节点，直至叶子节点，算出每条路径之和，与目标值targetSum 比较。这里有几个值得注意的点，在递归时应当以判断是否为叶子节点递归，而不是指针是否为空。传入的bool值应为引用

下面是代码：

class Solution {//深度优先遍历
public:
    void sum_path(bool & _b,TreeNode* _root, int _sum,int _goal){
        _goal+=_root->val;
        if(_root->left==NULL&&_root->right==NULL){
            if(_goal==_sum) _b=true;
            return;
        }
        if(_root->left!=NULL&&!_b)
        sum_path(_b,_root->left, _sum,_goal);
        if(_root->right!=NULL&&!_b)
        sum_path(_b,_root->right, _sum,_goal);

        if(_b) return;
    }
    bool hasPathSum(TreeNode* root, int sum) {
        bool b=false;
        int goal=0;
        if(root==NULL) return b;
        sum_path(b,root, sum,goal);
        return b;
    }
};

2、思路二、广度优先搜索：BFS

也就是层序遍历，用队列纪录每层相加的值，判断是否是路径和方法如同深度优先遍历一样。判断是否为叶子节点

class Solution {//广度优先遍历，两个队列
public:
    bool hasPathSum(TreeNode* root, int sum) {
        bool b=false;
        if(root==NULL) return b;
        queue<TreeNode*> qTree;
        queue<int> q_Val;

        qTree.push(root);
        q_Val.push(root->val);

        while(!qTree.empty()){
            //cout<<1<<endl;
            int l=qTree.size();

            for(int i=1;i<=l;++i){
                int val_=q_Val.front();
                TreeNode* q=qTree.front();
                qTree.pop();
                q_Val.pop();
                if(q->left) {
                    q_Val.push(q->left->val+val_);
                    qTree.push(q->left);
                }
                if(q->right) {
                    q_Val.push(q->right->val+val_);
                    qTree.push(q->right);
                }

                if(q->left==NULL&&q->right==NULL){
                    if(val_==sum) b=true;
                }
            }
        }
        return b;
    }
};