Path Sum

最新推荐文章于 2021-01-14 21:48:33 发布

临江别寄

最新推荐文章于 2021-01-14 21:48:33 发布

阅读量383

点赞数

分类专栏： leetCode 文章标签： Java LeetCode

本文链接：https://blog.csdn.net/yourijing/article/details/53955812

版权

leetCode 专栏收录该内容

11 篇文章 0 订阅

订阅专栏

Given a binary tree and a sum, determine if the tree has a root-to-leaf path such that adding up all the values along the path equals the given sum.

For example:
Given the below binary tree and sum = 22 ,

              5
             / \
            4   8
           /   / \
          11  13  4
         /  \      \
        7    2      1

return true, as there exist a root-to-leaf path 5->4->11->2 which sum is 22.

找到一棵二叉树的路径，使得该路径的和为目标值。

看到树的题目，不禁第一个念想就是递归 12.85%

public class Solution {
    public boolean hasPathSum(TreeNode root, int sum) {
        int result  = 0;
        if(root == null){
            return false;
        }
        boolean bool = hasPathSum(root,sum,result);
        return bool;
    }
    public boolean hasPathSum(TreeNode root, int sum,int result){
        if(root.left == null && root.right == null){
            result += root.val;
            if(result == sum){
                return true;
            }else{
                return false;
            }
        }else{
            result += root.val;
            boolean boleft = false;
            boolean bolright = false;
            if(root.left != null){
                boleft = hasPathSum(root.left,sum,result);
            }
            if(root.right != null){
                bolright = hasPathSum(root.right,sum,result);
            }
            if(boleft || bolright){
                return true;
            }
            return false;
        }
    }
}

当然啦，代码优化上，九章算法提供的代码代码更整洁

public class Solution {
    public boolean hasPathSum(TreeNode root, int sum) {
         if (root == null) {
            return false;
        }
        if (root.left == null && root.right == null) {
            return sum == root.val;
        }
        return hasPathSum (root.left, sum - root.val)
            || hasPathSum(root.right, sum - root.val);
    }
}

然后想想其实先序遍历也是可以的,效率低于递归算法。

public class Solution {
    public boolean hasPathSum(TreeNode root, int sum) {
        Stack<TreeNode> s = new Stack<TreeNode>();
        TreeNode pre = null, cur = root;
        int SUM = 0;
        while (cur != null || !s.empty()) {
            while (cur != null) {
                s.push(cur);
                SUM += cur.val;
                cur = cur.left;
            }
            cur = s.peek();
            if (cur.left == null && cur.right == null && SUM == sum) {
                return true;
            }
            if (cur.right != null && pre != cur.right) {
                cur = cur.right;
            } else {
                pre = cur;
                s.pop();
                SUM -= cur.val;
                cur = null;
            }
        }
        return false;
   }
}