LeetCode112.路径总和——————java

最新推荐文章于 2024-09-08 00:45:00 发布

GO!!!

最新推荐文章于 2024-09-08 00:45:00 发布

阅读量179

点赞数

CC 4.0 BY-SA版权

分类专栏： leetcode 文章标签： java 深度优先算法

本文链接：https://blog.csdn.net/m0_51799816/article/details/125398277

leetcode 专栏收录该内容

54 篇文章

订阅专栏

这篇博客介绍了两种解决二叉树中是否存在和为目标值的路径的方法。第一种是使用广度优先搜索（BFS）的迭代法，通过队列存储节点和路径值，不断检查是否找到目标和的叶子节点。第二种是采用深度优先搜索（DFS）的递归法，直接检查当前节点是否为叶子节点并比较其值，或者递归地在左、右子树中寻找路径。这两种方法都是针对二叉树的典型应用，适用于解决树结构中的路径问题。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目描述：
给你二叉树的根节点 root 和一个表示目标和的整数 targetSum 。判断该树中是否存在根节点到叶子节点的路径，这条路径上所有节点值相加等于目标和 targetSum 。如果存在，返回 true ；否则，返回 false 。

叶子节点是指没有子节点的节点。

示例 1：

输入：root = [5,4,8,11,null,13,4,7,2,null,null,null,1], targetSum = 22
输出：true 解释：等于目标和的根节点到叶节点路径如上图所示。示例 2：

输入：root = [1,2,3], targetSum = 5 输出：false 解释：树中存在两条根节点到叶子节点的路径： (1 -->
2): 和为 3 (1 --> 3): 和为 4 不存在 sum = 5 的根节点到叶子节点的路径。示例 3：

输入：root = [], targetSum = 0 输出：false 解释：由于树是空的，所以不存在根节点到叶子节点的路径。

解法一：广度优先搜索——迭代法

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public boolean hasPathSum(TreeNode root, int targetSum) {
        if(root==null)
        {
            return false;
        }
        Queue<TreeNode> queNode=new LinkedList<>();
        Queue<Integer> queInt=new LinkedList<>();
        queNode.offer(root);
        queInt.offer(root.val);
        while(!queNode.isEmpty())
        {
            TreeNode node=queNode.poll();
            int temp=queInt.poll();

            if(node.left==null&&node.right==null)
            {
                if(temp==targetSum)
                {
                    return true;
                }else
                {
                    continue;
                }
            }

            if(node.left!=null)
            {
                queNode.offer(node.left);
                queInt.offer(temp+node.left.val);
            }
            if(node.right!=null)
            {
                queNode.offer(node.right);
                queInt.offer(temp+node.right.val);
            }

        }
        return false;
          
    }
}

解法二：深度优先搜索——递归法：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    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.right,targetSum-root.val)||hasPathSum(root.left,targetSum-root.val);

          
    }
}