【LeetCode-树】路径总和

题目描述

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

给定如下二叉树，以及目标和 sum = 22，
              5
             / \
            4   8
           /   / \
          11  13  4
         /  \      \
        7    2      1

返回 true, 因为存在目标和为 22 的根节点到叶子节点的路径 5->4->11->2。

给定sum=1，以及树
  1
 /
2
返回false。

题目链接： https://leetcode-cn.com/problems/path-sum/

思路1

使用递归。代码如下：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    bool hasPathSum(TreeNode* root, int sum) {
        if(root==nullptr) return false;

        if(sum-root->val==0 && root->left==nullptr && root->right==nullptr){
            return true;
        }
        
        return hasPathSum(root->left, sum-root->val) || hasPathSum(root->right, sum-root->val);
    }
};

• 时间复杂度：O(n)
  n为树中节点个数。
• 空间复杂度：O(logN)
  logN是树的高度。

思路2

也是递归，但实现比思路 1 复杂一些。代码如下：

/**
 * struct TreeNode {
 *	int val;
 *	struct TreeNode *left;
 *	struct TreeNode *right;
 * };
 */

class Solution {
public:
    /**
     * 
     * @param root TreeNode类 
     * @param sum int整型 
     * @return bool布尔型
     */
    bool hasPathSum(TreeNode* root, int sum) {
        if(root==nullptr) return false;
        
        bool ans = false;
        dfs(root, root->val, ans, sum);
        return ans;
    }
    
    void dfs(TreeNode* root, int curSum, bool& ans, int& sum){
        if(root==nullptr) return;
        if(!root->left && !root->right){
            if(curSum==sum){
                ans = true;
                return;
            }else return;
        }
        if(ans) return;
        
        if(root->left){
            dfs(root->left, curSum+root->left->val, ans, sum);
        }
        if(root->right){
            dfs(root->right, curSum+root->right->val, ans, sum);
        }
    }
};

思路3

使用迭代。这个方法使用两个栈来进行dfs，一个栈存储节点，另一个栈存储当前的数值。代码如下：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    bool hasPathSum(TreeNode* root, int sum) {
        if(root==nullptr) return false;

        stack<TreeNode*> nodeStack;
        stack<int> sumStack;
        nodeStack.push(root);
        sumStack.push(sum-root->val);
        while(!nodeStack.empty()){
            TreeNode* curNode = nodeStack.top();
            nodeStack.pop();
            int curSum = sumStack.top();
            sumStack.pop();
            if(curNode->left==nullptr&&curNode->right==nullptr&&curSum==0){
                return true;
            }else{
                if(curNode->left!=nullptr){
                    nodeStack.push(curNode->left);
                    sumStack.push(curSum-curNode->left->val);
                }
                if(curNode->right!=nullptr){
                    nodeStack.push(curNode->right);
                    sumStack.push(curSum-curNode->right->val);
                }
            }
        }
        return false;
    }
};

• 时间复杂度：O(N)
• 空间复杂度：O(N)