leetcode 112 路径总和 i 、113 路径总和 ii

路径总和 i

法一、递归

bool sumNode(TreeNode* root, int targetSum, int sum) {
     sum += root->val;
     //遇到叶子节点结束迭代
     if (!root->left && !root->right) return sum == targetSum;
     bool leftsum = false, rightsum = false;
     if (root->left) leftsum = sumNode(root->left, targetSum, sum);
     if (root->right) rightsum = sumNode(root->right, targetSum, sum);
     return leftsum || rightsum;
}
bool hasPathSum(TreeNode* root, int targetSum) {
     if (root == nullptr) return false;
     return sumNode(root, targetSum, 0);
}

法二：迭代

迭代的第一种写法 ——使用两个栈分别记录

if (root == nullptr) return false;
stack<TreeNode*> st;//记录结点
stack<int> stSum;//记录从根节点到结点的路径和
//因为要同时记录结点 以及 目前从根节点到结点的路径和，因此要么分别使用两个栈记录，要么就用一个栈存放pair类型
st.push(root);
stSum.push(root->val);
while (!st.empty()) {
    TreeNode* node = st.top(); st.pop();//当前节点
    int sum = stSum.top(); stSum.pop();//根节点到当前结点的路径和
    if (!node->left && !node->right && sum == targetSum) return true;
    if (node->left) {
          st.push(node->left);//st中push左子
          stSum.push(sum + node->left->val);//stSum中push从根节点到左子的路径和
    }
    if (node->right) {
          st.push(node->right);
          stSum.push(sum + node->right->val);//stSum中push从根节点到右子的路径和
     }
}
return false;

迭代的第二种写法 —— 就使用一个栈记录。

if (root == nullptr) return false;
stack<pair<TreeNode*, int>> st;
//因为要同时记录结点以及目前从根节点到结点的路径和，因此要么分别使用两个栈记录，要么就用一个栈存放pair类型
st.push(pair<TreeNode*, int>(root, root->val));
while (!st.empty()) {
   pair<TreeNode*, int> p = st.top(); st.pop();
   if (!p.first->left && !p.first->right && p.second == targetSum) return true;
   if (p.first->left) { //push<左子, 从根节点到左子的路径和>
       st.push(pair<TreeNode*, int>(p.first->left, p.second + p.first->left->val));
   }
   if (p.first->right) {
       st.push(pair<TreeNode*, int>(p.first->right, p.second + p.first->right->val));
   }
}
return false;

路径总和 ii

vector<vector<int>> res;
vector<int> path;
void findPath(TreeNode* node, int targetSum, int sum) {
    path.push_back(node->val);//记录路径
    sum += node->val;//记录目前为止路径的总和
    if (!node->left && !node->right && sum == targetSum) {
        //找到了一条符合条件的路径就将该条路径加入res
        res.push_back(path);
    } 
    if (node->left) {
        findPath(node->left, targetSum, sum);
        path.pop_back();//回溯（核心！）
        //因为每次递归都只在开头执行一次path.push_back()，即每次递归path中都只会加入一个结点值，因此执行完一次递归(push一次)再pop一次就能回到之前的path
    }
    if (node->right) {
        findPath(node->right, targetSum, sum);
        path.pop_back();//同理
    }
}
vector<vector<int>> pathSum(TreeNode* root, int targetSum) {
    if (root == nullptr) return res;
    findPath(root, targetSum, 0);
    return res;
}