LeetCode一周题解（20220418-20220424）_public void preorder(list<integer> list-CSDN博客

本文链接：https://blog.csdn.net/weixin_51558132/article/details/124257781

本周是二叉树专刷。

前序遍历是根--->左---->右遍历

/**
 * 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 List<Integer> preorderTraversal(TreeNode root) {
        List<Integer>list=new ArrayList();
        preorder(list,root);
        return list;
    }
    public void preorder(List<Integer>list,TreeNode root){
        if(root==null){
            return;
        }
        list.add(root.val);
        preorder(list,root.left);
        preorder(list,root.right);
    }
}

#94 二叉树的中序遍历

中序遍历是：左--->根--->右遍历

/**
 * 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 List<Integer> inorderTraversal(TreeNode root) {
        List<Integer>list=new ArrayList();
        inorder(list,root);
        return list;
    }
    public void inorder(List<Integer>list,TreeNode root){
        if(root==null) return;
        inorder(list,root.left);
        list.add(root.val);
        inorder(list,root.right);
    }
}

#145 二叉树的后序遍历

后序遍历是：左--->右----->后遍历

递归：

/**
 * 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 List<Integer>res=new ArrayList();
    public List<Integer> postorderTraversal(TreeNode root) {
        if(root==null) return res;
        postorderTraversal(root.left);
        postorderTraversal(root.right);
        res.add(root.val);
        return res;

    }
}

#104 二叉树的最大深度

二叉树的深度就是二叉树的根结点到子结点的距离（子结点为无左右孩子的结点）；

/**
 * 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 int maxDepth(TreeNode root) {
        if(root==null) return 0;
        return Math.max(maxDepth(root.left),maxDepth(root.right))+1;

    }
}

#101 对称二叉树

想通递归的条件，就是对称要求该节点左孩子和对称节点的右孩子相等，该节点的右孩子和对称节点的左孩子相等。

/**
 * 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 isSymmetric(TreeNode root) {
        if(root==null) return true;
        return cmp(root.left,root.right);
    }
    public boolean cmp(TreeNode node1,TreeNode node2){
        if(node1==null&&node2==null){
            return true;
        }
        if(node1==null||node2==null||node1.val!=node2.val){
            return false;
        }
        return cmp(node1.left,node2.right)&&cmp(node1.right,node2.left);

    }
}

#100 相同的树

根结点相同，左结点要相同，右结点要相同

/**
 * 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 isSameTree(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;
        if(p.val==q.val){
            return isSameTree(p.left,q.left)&&isSameTree(p.right,q.right);
        }
        return true;

    }
}

#965 单值二叉树

判断左结点等不等于根结点，右孩子等不等于根结点，递归

/**
 * 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 isUnivalTree(TreeNode root) {
        if(root==null){
            return true;
        }
        if(root.left!=null&&root.left.val!=root.val){
            return false;
        }
        if(root.right!=null&&root.right.val!=root.val){
            return false;
        }
        return isUnivalTree(root.right)&&isUnivalTree(root.left);

    }
}

#102 二叉树的层序遍历

用一个队列维护进来的结点，然后将结点从左到右加入

/**
 * 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 List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>>res=new ArrayList();
        if(root==null) return res;
        Queue<TreeNode>q=new ArrayDeque<TreeNode>();
        q.add(root);
        while(!q.isEmpty()){
            ArrayList<Integer>row=new ArrayList();
            int n=q.size();
            for(int i=0;i<n;i++){
                TreeNode cur=q.poll();
                row.add(cur.val);
                if(cur.left!=null){
                    q.add(cur.left);
                }
                if(cur.right!=null){
                    q.add(cur.right);
                }
            }
            res.add(row);
        }
        return res;

    }
}

#572 另一棵树的子树

理解子树的概念就能写出递归做法

/**
 * 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 isSameTree(TreeNode s,TreeNode t){
        if(s==null&&t==null){
            return true;
        }
        if(s==null||t==null){
            return false;
        }
        if(s.val!=t.val){
            return false;
        }
        return isSameTree(s.left,t.left) && isSameTree(s.right,t.right);
    }
    public boolean isSubtree(TreeNode root, TreeNode subRoot) {
        if(root==null) return false;
        return isSameTree(root,subRoot)||isSubtree(root.left,subRoot)||isSubtree(root.right,subRoot);
        

    }
}

#257 二叉树的所有路径

/**
 * 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 List<String> binaryTreePaths(TreeNode root) {
        List<String>ans=new ArrayList();
        if(root==null) return ans;
        binaryTreePaths(root,ans,"");
        return  ans;
    }
    void binaryTreePaths(TreeNode root,List<String>ans,String path){
        path+=root.val;
        if(root.left==null&&root.right==null){
            ans.add(path);
            return;
        }
        if(root.left!=null) binaryTreePaths(root.left,ans,path+"->");
        if(root.right!=null) binaryTreePaths(root.right,ans,path+"->");
    }
}

#1022 从根到叶的二进制数之和

/**
 * 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 int sumRootToLeaf(TreeNode root) {
        return helper(root,0);
    }
    private int helper(TreeNode root,int sum){
        if(root==null) return 0;
        sum=sum*2+root.val;
        if(root.left==null&&root.right==null){
            return sum;
        }
        return helper(root.left,sum)+helper(root.right,sum);
    }
}

#513 找树左下角的值

左下角是最深那一层的最左边，不是单纯的左孩子。层序遍历解决。

/**
 * 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 int findBottomLeftValue(TreeNode root) {
        Queue<TreeNode>q=new LinkedList<>();
        q.offer(root);
        TreeNode res=root;
        while(!q.isEmpty()){
            TreeNode cur=q.poll();
            if(cur.right!=null){
                q.add(cur.right);
                res=cur.right;
            }
            if(cur.left!=null){
                q.add(cur.left);
                res=cur.left;
            }
        }
        return res.val;

    }
}

#129 求根节点到叶节点数字之和

/**
 * 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 int sumNumbers(TreeNode root) {
        return helper(root,0);
    }
    public int helper(TreeNode root,int sum){
        if(root==null) return 0;
        sum=sum*10+root.val;
        if(root.left==null&&root.right==null){
            return sum;
        }
        return helper(root.left,sum)+helper(root.right,sum);
    }
}

#872 叶子相似的树

前序遍历

/**
 * 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 leafSimilar(TreeNode root1, TreeNode root2) {
         return traverse(root1,"").equals(traverse(root2,""));
    }
    public String traverse(TreeNode root,String str){
        if(root==null) return str;
        if(root.left==null&&root.right==null){
            str+=root.val;
        }
        return traverse(root.left,str)+traverse(root.right,str);
    }
}

#404 左叶子之和

本质还是前序遍历

/**
 * 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 int sumOfLeftLeaves(TreeNode root) {
        if(root==null) return 0;
        int ans=0;
        if(root.left!=null&&root.left.left==null&&root.left.right==null){
            ans+=root.left.val;
        }
        return sumOfLeftLeaves(root.left)+sumOfLeftLeaves(root.right)+ans;

    }
}

#112 路径总和

其实还是前序遍历的变式

/**
 * 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 targetSum-root.val==0;
        return hasPathSum(root.left,targetSum-root.val)||hasPathSum(root.right,targetSum-root.val);

    }
}

#113 路径总和 II

/**
 * 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 List<List<Integer>> pathSum(TreeNode root, int targetSum) {
        if(root==null) return new ArrayList<>();
        List<List<Integer>> ans=new ArrayList();
        if(root.val==targetSum&&root.left==null&&root.right==null){
            List<Integer>row=new ArrayList();
            row.add(root.val);
            ans.add(row);
            return ans;
        }
        List<List<Integer>>left=pathSum(root.left,targetSum-root.val);
        List<List<Integer>>right=pathSum(root.right,targetSum-root.val);
        for(List<Integer>list:left){
            list.add(0,root.val);
            ans.add(list);
        }
        for(List<Integer>list:right){
            list.add(0,root.val);
            ans.add(list);
        }
        return ans;

    }
}