题目:
没看解析之前自己用深度优先搜索实现:
遍历整棵二叉树,将所有叶子节点的路径之和添加到list中,再遍历list集合,判断是否有targetsum相等的路径。
List<Integer> list = new ArrayList<Integer>();
public boolean hasPathSum(TreeNode root, int targetSum) {
dfs(root,0);
for(int i = 0; i < list.size(); i++){
if(list.get(i) == targetSum){
return true;
}
}
return false;
}
public void dfs(TreeNode root,int path){
if(root == null){
return;
}
//如果当前节点是叶子节点,就将当前节点路径加入list
if(root.left == null && root.right == null){
list.add(path + root.val);
}
//递归遍历左右树
dfs(root.left,path + root.val);
dfs(root.right,path + root.val);
}
优化后(官方题解):
不用list存储每一个叶子结点的路径,利用递归将targetsum值递减,将大问题化解为小问题。
我们要求root节点到某一叶子节点的距离是否为tergetSum,也就是判断root的子节点(左右节点)
到某一叶子节点的距离是否为targetSum - root.val即可,这样如果当前节点是叶子结点的时候,判断当前节点值是否等于targetSum即可
public boolean hasPathSum(TreeNode root, int targetSum) {
if(root == null){
return false;
}
if(root.left == null && root.right == null){
return root.val == targetSum;
}
return hasPathSum(root.left,targetSum - root.val) ||
hasPathSum(root.right,targetSum - root.val);
}
广度优先搜索实现:
用两个队列来同步存储节点和节点路径
public boolean hasPathSum(TreeNode root, int targetSum) {
if(root == null){
return false;
}
Queue<TreeNode> nodequeue = new LinkedList<TreeNode>();
Queue<Integer> pathqueue = new LinkedList<Integer>();
//同时入队列
nodequeue.offer(root);
pathqueue.offer(root.val);
while(!nodequeue.isEmpty()){
//同时出队列
TreeNode node = nodequeue.poll();
int path = pathqueue.poll();
//如果是叶子节点判断路径值是否等于targetSum
if(node.left == null && node.right == null){
if(path == targetSum){
return true;
}
//如果是叶子节点,就不用判断当前循环中下面语句
continue;
}
if(node.left != null){
nodequeue.offer(node.left);
pathqueue.offer(node.left.val + path);
}
if(node.right != null){
nodequeue.offer(node.right);
pathqueue.offer(node.right.val + path);
}
}
return false;
}