【LeetCode】Day28-路径总和

最新推荐文章于 2024-07-19 00:42:57 发布

倒过来是圈圈

最新推荐文章于 2024-07-19 00:42:57 发布

阅读量637

点赞数

分类专栏： Leetcode进阶之路文章标签： leetcode 算法 java

本文链接：https://blog.csdn.net/qq_43417265/article/details/123997687

版权

Leetcode进阶之路专栏收录该内容

232 篇文章 1 订阅

订阅专栏

题目1

101. 对称二叉树【简单】

题解

以前做过，还是忘了…

如果同时满足下面的条件，两个树互为镜像：

它们的两个根结点具有相同的值
每个树的右子树都与另一个树的左子树镜像对称

递归

class Solution {
    public boolean isSymmetric(TreeNode root) {
        return check(root,root);
    }
    public boolean check(TreeNode l,TreeNode r){
        if(l==null&&r==null)
            return true;
        if(l==null||r==null)
            return false;
        return l.val==r.val&&check(l.left,r.right)&&check(l.right,r.left);
    }
}

时间复杂度： $O (n)$

空间复杂度： $O (n)$

迭代

用队列实现递归

class Solution {
    public boolean isSymmetric(TreeNode root) {
        Queue<TreeNode>queue=new LinkedList<>();
        queue.offer(root);
        queue.offer(root);
        while(!queue.isEmpty()){
            TreeNode p=queue.poll();
            TreeNode q=queue.poll();
            if(p==null&&q==null)
                continue;
                
            if(p==null||q==null)
                return false;

            if(p.val!=q.val)
                return false;

            queue.offer(p.left);
            queue.offer(q.right);

            queue.offer(p.right);
            queue.offer(q.left);
        }
        return true;
    }
}

时间复杂度： $O (n)$

空间复杂度： $O (n)$

题目2

112. 路径总和【简单】

题解

BFS

利用树的层次遍历，增加一个队列存储根节点到对应结点的路径长度，到叶子结点的时候判断是否等于targetSum（注意不能提前判断，因为树的结点可能有负值）

class Solution {
    public boolean hasPathSum(TreeNode root, int targetSum) {
        if(root==null)
            return false;
        Queue<TreeNode>queueTree=new LinkedList<>();//存储结点
        Queue<Integer>queueVal=new LinkedList<>();//存储到该节点的路径长度
        queueTree.offer(root);
        queueVal.offer(root.val);
        
        while(!queueTree.isEmpty()){
            TreeNode p=queueTree.poll();
            int sumTmp=queueVal.poll();
            //叶子节点
            if(p.left==null&&p.right==null){
                if(sumTmp==targetSum)
                    return true;
                continue;
            }
            //非叶子结点,继续遍历
            if(p.left!=null){
                queueTree.offer(p.left);
                queueVal.offer(p.left.val+sumTmp);
            }
            if(p.right!=null){
                queueTree.offer(p.right);
                queueVal.offer(p.right.val+sumTmp);
            }
        }
        return false;
    }
}

时间复杂度： $O (n)$

空间复杂度： $O (n)$

递归

从根节点到当前节点的值之和为 sum => 假定从根节点到当前节点的值之和为 val，是否存在从当前节点的子节点到叶子的路径，满足其路径和为 sum - val。

相当于 自顶（根）向下 转换为了 自底（叶子）向上

class Solution {
    public boolean hasPathSum(TreeNode root, int targetSum) {
        if(root==null)
            return false;
        
        int leftSum=targetSum-root.val;//sum-val
        if(root.left==null&&root.right==null)
            return leftSum==0;
        
        //注意是"或"的关系,左右有一边就行
        return hasPathSum(root.left,leftSum)||hasPathSum(root.right,leftSum);
    }
}