算法通关村--第八关青铜挑战

最新推荐文章于 2024-08-13 23:31:35 发布

用沉默咆哮

最新推荐文章于 2024-08-13 23:31:35 发布

阅读量27

点赞数

文章标签：算法 leetcode 数据结构

本文链接：https://blog.csdn.net/weixin_42883548/article/details/134254457

版权

文章介绍了Java中的树结构类及其方法，包括检查两个树是否相同、判断树是否对称、合并树、生成二叉树路径、查找路径和节点反转等深度优先搜索操作。

摘要由CSDN通过智能技术生成

class Solution {
    public boolean check(TreeNode p,TreeNode q){
        if(p==null&q==null)
            return true;
        if(p==null||q==null)
            return false;
        if(p.val!=q.val)
            return false;
        return check(p.left,q.left)&&check(p.right,q.right);
    }
    public boolean isSameTree(TreeNode p, TreeNode q) {
        boolean ans=check(p,q);
        return ans;
    }
}

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

class Solution {
    public TreeNode combine(TreeNode root1,TreeNode root2){
        if(root1==null&&root2==null)
            return null;
        if(root1==null)
            return root2;
        if(root2==null)
            return root1;
        root1.val+=root2.val;
        root1.left=combine(root1.left,root2.left);
        root1.right=combine(root1.right,root2.right);
        return root1;
    }
    public TreeNode mergeTrees(TreeNode root1, TreeNode root2) {
        root1=combine(root1,root2);
        return root1;
    }
}

class Solution {
    public void dfs(TreeNode root,String way,List<String> ans){
        if(root==null){
            return;
        }
        if(way.equals(""))
            way=way+""+root.val;
        else
            way=way+"->"+root.val;
        if(root.left==null&&root.right==null){
            ans.add(way);
            return;
        }
        dfs(root.left,way,ans);
        dfs(root.right,way,ans);
    }
    public List<String> binaryTreePaths(TreeNode root) {
        List<String> ans=new ArrayList<String>();
        dfs(root,"",ans);
        return ans;
    }
}

class Solution {
    boolean ans=false;
    public void dfs(TreeNode root,int targetSum,int sum){
        if(root==null)
            return;
        sum+=root.val;
        if(root.left==null&&root.right==null){
            if(sum==targetSum)
                ans=true;
        }
        dfs(root.left,targetSum,sum);
        dfs(root.right,targetSum,sum);
    }
    public boolean hasPathSum(TreeNode root, int targetSum) {
        dfs(root,targetSum,0);
        return ans;
    }
}

class Solution {
    public TreeNode dfs(TreeNode left,TreeNode right,TreeNode node){
        if(node==null){
            if(node==left)
                return right;
            if(node==right)
                return left;            
        }
        TreeNode node_left=node.left;
        TreeNode node_right=node.right;
        node.left=dfs(node_left,node_right,node_left);
        node.right=dfs(node_left,node_right,node_right);        
        if(node==left)
            return right;
        if(node==right)
            return left;
        return node;
    }
    public TreeNode invertTree(TreeNode root) {
        root=dfs(null,null,root);
        return root;
    }
}