代码随想录算法训练营第24天|LeetCode112.路径总和、LeetCode113.路径总和ii

代码随想录算法训练营第24天|LeetCode112.路径总和、LeetCode113.路径总和ii

1、LeetCode112.路径总和

112. 路径总和 - 力扣（LeetCode）

递归法

第一想法：递归，每一次传递target减去已经经过得，一直找到叶子节点&&targetsum为0，返回true。

1. 函数参数及返回值

bool hasPathSum(TreeNode* root, int targetSum)

2. 终止条件

是叶子节点&&叶子节点val==targetSum。

3. 单层逻辑

继续递归传递，只要左右节点有一方true则true。

代码：

一遍过！但是写得时候思路有变化。本来单层逻辑是分开来return的，后面感觉逻辑不对就改成现在正确的了。

class Solution {
public:
    bool hasPathSum(TreeNode* root, int targetSum) {
        if(root == NULL)
            return false;
        // 终止条件
        if(root->left == NULL && root->right == NULL && root->val == targetSum){
            return true;
        }
        // 单层逻辑
        return hasPathSum(root->left, targetSum-(root->val)) || hasPathSum(root->right, targetSum-(root->val));

    }
};

迭代法

没有自己动手写。看起来简单，之和有时间敲一下。

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

2、LeetCode113.路径总和ii

113. 路径总和 II - 力扣（LeetCode）

这道题和上一道题做对比，题目是差不多一样的，只不过一个返回true or false，此题返回路径。因此递归函数什么时候有返回值是需要辨别的。如上一题就需要，且返回值为bool类型，但这一题由于要返回路径，因此不需要返回值而是把路径存储下来。

代码

虽然一遍过了，但是写之前没有完全想好递归三部曲，导致后面有一丁点乱。

忘记了vector删除元素的方法：erase()按位置删除元素。pop_back()删除最后一个元素。

class Solution {
public:
    vector<vector<int> > res;
    void getPath(TreeNode* root, int targetSum, vector<int> path){
        // 终止条件
        if(!root->left && !root->right && root->val == targetSum){
            path.push_back(root->val);
            res.push_back(path);
            return ;
        }
        path.push_back(root->val);
        if(root->left){
            getPath(root->left, targetSum - root->val, path);
        }
        if(root->right){
            getPath(root->right, targetSum - root->val, path);
        }
    }
    vector<vector<int>> pathSum(TreeNode* root, int targetSum) {
        if(root == NULL)
            return res;
        vector<int> path;
        // path.push_back(root->val);
        getPath(root, targetSum, path);
        return res;
    }
};