解法一:递归调用,时间复杂度O(N),空间复杂度O(log(N)),因为遍历了所有的节点,最终将所有的可能返回的结果或运算,所以需要保存每种可能返回的结果,即只需要保存叶子节点的数目,最多只会log(N)
import java.util.*;
/*
* public class TreeNode {
* int val = 0;
* TreeNode left = null;
* TreeNode right = null;
* }
*/
public class Solution {
/**
*
* @param root TreeNode类
* @param sum int整型
* @return bool布尔型
*/
public boolean hasPathSum (TreeNode root, int sum) {
// write code here
if (root == null) {
return false;
}
if (root.left == null && root.right == null && sum == root.val) {
return true;
}
//递归调用
return hasPathSum(root.left, sum - root.val) || hasPathSum(root.right, sum - root.val);
}
}
第二种方法:非递归,时间复杂度O(N),空间复杂度O(N),因为需要保存所有的节点,所以空间复杂度O(N)。
import java.util.*;
/*
* public class TreeNode {
* int val = 0;
* TreeNode left = null;
* TreeNode right = null;
* }
*/
public class Solution {
/**
*
* @param root TreeNode类
* @param sum int整型
* @return bool布尔型
*/
public boolean hasPathSum (TreeNode root, int sum) {
// write code here
if (root == null) {
return false;
}
Stack<TreeNode> stack = new Stack<>();
stack.push(root);
while (!stack.isEmpty()) {
TreeNode node = stack.pop();
if (node.left == null && node.right == null && sum == node.val) {
return true;
}
if (node.left != null) {
node.left.val = node.val + node.left.val;
stack.push(node.left);
}
if (node.right != null) {
node.right.val = node.val + node.right.val;
stack.push(node.right);
}
}
return false;
}
}
第三种方法:dfs,时间复杂度O(N),空间复杂度O(log(N))
import java.util.*;
/*
* public class TreeNode {
* int val = 0;
* TreeNode left = null;
* TreeNode right = null;
* }
*/
public class Solution {
/**
*
* @param root TreeNode类
* @param sum int整型
* @return bool布尔型
*/
public boolean hasPathSum (TreeNode root, int sum) {
// write code here
if (root == null) {
return false;
}
return dfs(root, sum);
}
private boolean dfs(TreeNode root, int sum) {
if (root == null) {
return false;
}
//叶子节点
if (root.left == null && root.right == null && sum == root.val) {
return true;
};
boolean resultLeft = false;
boolean resultRight = false;
if (root.left != null) {
resultLeft = resultLeft || dfs(root.left, sum - root.val);
}
if (root.right != null) {
resultRight = resultRight || dfs(root.right, sum - root.val);
}
return resultLeft || resultRight;
}
}
第四种方法:bfs,时间复杂度O(N),空间复杂度O(N),因为需要保存所有的节点,所以空间复杂度O(N)。
import java.util.*;
/*
* public class TreeNode {
* int val = 0;
* TreeNode left = null;
* TreeNode right = null;
* }
*/
public class Solution {
/**
*
* @param root TreeNode类
* @param sum int整型
* @return bool布尔型
*/
public boolean hasPathSum (TreeNode root, int sum) {
// write code here
if (root == null) {
return false;
}
Queue<TreeNode> queue = new LinkedList<>();
queue.offer(root);
while (!queue.isEmpty()) {
TreeNode node = queue.poll();
if (node.left == null && node.right == null && sum == node.val) {
return true;
}
if (node.left != null) {
node.left.val = node.val + node.left.val;
queue.add(node.left);
}
if (node.right != null) {
node.right.val = node.val + node.right.val;
queue.add(node.right);
}
}
return false;
}
}