力扣：112. 路径总和

力扣：112. 路径总和
代码随想录

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

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

思考方法：
一：问题：是否存在根节点到叶子节点的路径，所有节点值相加等于标准值。
二：解决方法、遍历顺序：先序遍历、用参数记录路径值。
三：代码随想录三步走
1：返回值bool类型，传入根节点，路径值、标准值。
2：写主体代码。找到了叶子结点且路径值等于标准值。
写主体代码时思考到路径值初始要相加。

sum += root->val;
if(!root->left && !root->right && sum == targetSum) return true;

3：
先序遍历、然后分为根节点、左树、右树。写递归函数用函数的意思来思考a = findroute(root->left, sum, targetSum);：
左子树有这条路径
右子树有这条路径
最后要返回结果，左子树路径可能性 || 右子树路径可能性。
路径可能性要初始化为 false 一开始掉了搞的代码过不去。

     bool a = false,b = false;
     if(root->left)  a = findroute(root->left, sum, targetSum);
        if(root->right)  b = findroute(root->right, sum, targetSum);
        return a||b;

代码：

class Solution {
public:
    bool findroute(TreeNode* root, int sum,int targetSum){
        sum += root->val;
        if(!root->left && !root->right && sum == targetSum) return true;
        bool a = false,b = false;
        if(root->left)  a = findroute(root->left, sum, targetSum);
        if(root->right)  b = findroute(root->right, sum, targetSum);
        return a||b;
    }
    bool hasPathSum(TreeNode* root, int targetSum) {
        if(!root) return false;
        return findroute(root, 0, targetSum);
    }
};

第一种代码是通过累加等于标准值，这一种代码是标准值一直减直到0，不存在则false。
第二种代码：

class solution {
private:
    bool traversal(treenode* cur, int count) {
        if (!cur->left && !cur->right && count == 0) return true; // 遇到叶子节点，并且计数为0
        if (!cur->left && !cur->right) return false; // 遇到叶子节点直接返回

        if (cur->left) { // 左
            count -= cur->left->val; // 递归，处理节点;
            if (traversal(cur->left, count)) return true;
            count += cur->left->val; // 回溯，撤销处理结果
        }
        if (cur->right) { // 右
            count -= cur->right->val; // 递归，处理节点;
            if (traversal(cur->right, count)) return true;
            count += cur->right->val; // 回溯，撤销处理结果
        }
        return false;
    }

public:
    bool haspathsum(treenode* root, int sum) {
        if (root == null) return false;
        return traversal(root, sum - root->val);
    }
};

迭代法：
遍历每一个节点，储存每一个节点的路径值***用pair<treenode, int>，直到遇到叶子结点且值为标准值。
代码：

class solution {

public:
    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;
    }
};