LeetCode112-路径总和

 

非商业，LeetCode链接附上：

https://leetcode-cn.com/problems/path-sum/

进入正题。

 

题目：

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

说明: 叶子节点是指没有子节点的节点。

 

示例: 
给定如下二叉树，以及目标和 sum = 22，

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

 

代码实现：

//节点
class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;
  
        public TreeNode(int val) {
            this.val = val;
        }
}

//方法一 递归
public boolean hasPathSum(TreeNode root, int sum) {

        if(root == null) {
            return false;
        }
        
        if(root.left == null && root.right == null) {
            return root.val == sum;
        }
        
        return hasPathSum(root.left, sum - root.val) || hasPathSum(root.right, sum - root.val);
}
//时间复杂度O(n)，空间复杂度：O(H)，其中 H 是树的高度。

//方法二 迭代
public boolean hasPathSum(TreeNode root, int sum) {

        if(root == null) {
            return false;
        }
        Queue<TreeNode> queNode = new LinkedList<>();
        Queue<Integer> queVal = new LinkedList<>();
        queNode.offer(root);
        queVal.offer(root.val);
        
        while (!queNode.isEmpty()) {
            
            TreeNode node = queNode.poll();
            int temp = queVal.poll();
            
            if(node.left == null && node.right == null) {
                if(sum == temp) {
                    return true;
                }
                continue;
            }
            
            if(node.left != null) {
                queNode.offer(node.left);
                queVal.offer(node.left.val + temp);
            }
            if(node.right != null) {
                queNode.offer(node.right);
                queVal.offer(node.right.val + temp);
            }
        }
        
        return false;
}
//时间复杂度O(n)，空间复杂度O(n)

 

分析：

递归的方法，判断终止条件，并逐渐缩小问题规模；

迭代的方法，初始化一个队列(Queue)，记录到每一个节点对应的路径值。

 

--End