力扣刷题—树

一、相同树

如果两个二叉树都为空，则两个二叉树相同。如果两个二叉树中有且只有一个为空，则两个二叉树一定不相同。如果两个二叉树都不为空，那么首先判断它们的根节点的值是否相同，若不相同则两个二叉树一定不同，若相同，再分别判断两个二叉树的左子树是否相同以及右子树是否相同。这是一个递归的过程，因此可以使用深度优先搜索，递归地判断两个二叉树是否相同。

    public static boolean isSameTree(TreeNode p, TreeNode q) {
        if (p == null && q == null){
            return true;
        }else if (p == null || q == null){//走到这步说明一个null，一个不是null
            return false;
        }else if (p.val != q.val){//走到这都不是null
            return false;
        }else {//走到这说明树根相等，因此看左子树和右子树是否都相等
            return isSameTree(p.left,q.left) && isSameTree(p.right,q.right);
        }
    }

二、树的最大深度

利用后序遍历的思路，要求树的最大深度，需要知道左子树和右子树的最大深度，然后再+1。如下图所示。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9X2sve1W-1626578300304)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210709131649704.png)]

 public static int maxDepth(TreeNode root) {
        int maxLedf,maxRight;
        if (root != null){
            maxLedf = maxDepth(root.left);//求左子树深度
            maxRight = maxDepth(root.right);//求右子树深度
            return Math.max(maxLedf,maxRight) + 1;//返回树的深度
        }
        return 0;//空树深度为0
    }

三、树的最小深度

给定一个二叉树，找出其最小深度。

最小深度是从根节点到最近叶子节点的最短路径上的节点数量。

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

代码块一：

    public int minDepth(TreeNode root) {
        int minLedf,minRight;
        if (root != null){
            //斜树的情况
            if (root.left == null ^ root.right == null){//root.left和root.right有一个为null，一个不为null
                if (root.left == null){//如果root.left为null
                    //只需要返回右子树的深度+1
                    return minDepth(root.right) + 1;
                }
                if (root.right == null){//如果root.right为null
                    //只需要返回左子树的深度+1
                    return minDepth(root.left) + 1;
                }
            }
            //非斜树的情况
            minLedf = minDepth(root.left);
            minRight = minDepth(root.right);
            return Math.min(minLedf,minRight) + 1;
        }
        return 0;
    }

代码块二：

class Solution {
    public int minDepth(TreeNode root) {
        if (root == null) {
            return 0;
        }
        // 计算左子树的深度
        int left = minDepth(root.left);
        // 计算右子树的深度
        int right = minDepth(root.right);
        // 如果左子树或右子树的深度不为 0，即存在一个子树，那么当前子树的最小深度就是该子树的深度+1
        // 如果左子树和右子树的深度都不为 0，即左右子树都存在，那么当前子树的最小深度就是它们较小值+1
        return (left == 0 || right == 0) ? left + right + 1 : Math.min(left, right) + 1;
    }
}

四、路径总和

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

叶子节点 是指没有子节点的节点。

思路：观察要求我们完成的函数，我们可以归纳出它的功能：询问是否存在从当前节点 root 到叶子节点的路径，满足其路径和为 sum。

假定从根节点到当前节点的值之和为 val，我们可以将这个大问题转化为一个小问题：是否存在从当前节点的子节点到叶子的路径，满足其路径和为 sum - val。

不难发现这满足递归的性质，若当前节点就是叶子节点，那么我们直接判断 sum 是否等于 val 即可（因为路径和已经确定，就是当前节点的值，我们只需要判断该路径和是否满足条件）。若当前节点不是叶子节点，我们只需要递归地询问它的子节点是否能满足条件即可。

    public static boolean hasPathSum(TreeNode root, int targetSum) {
        if (root == null){
            return false;
        }
        if (root.left == null && root.right == null){//叶节点
            return targetSum == root.val;
        }else {
            //不是叶节点要继续向下递归,同时targetSum不断减去当前树根的值，
            //这样子最后到叶节点只要判断	targetSum是否等于叶节点的值
            //只要一个为true就返回true
            return hasPathSum(root.left,targetSum - root.val) 
                || hasPathSum(root.right,targetSum - root.val);
        }
    }

    public boolean hasPathSum(TreeNode root, int targetSum) {
        //队列方法
        Queue<TreeNode> queueNode = new LinkedList<>();
        Queue<Integer> queueValue = new LinkedList<>();
        if (root == null){
            return false;
        }
        queueNode.offer(root);
        queueValue.offer(root.val);
        while (!queueNode.isEmpty()){
            TreeNode curNode = queueNode.poll();
            int curVal = queueValue.poll();
            if (curNode.left == null && curNode.right == null){//叶节点
                if (curVal == targetSum){
                    return true;
                }
                continue;//如果该叶节点所在路径不满足，那么继续下次循环，因为后面的操作是针对非叶节点
            }
            if (curNode.left != null){
                queueNode.offer(curNode.left);
                queueValue.offer(curNode.left.val + curVal);
            }
            if (curNode.right != null){
                queueNode.offer(curNode.right);
                queueValue.offer(curNode.right.val + curVal);
            }
        }
        return false;
    }

五、平衡二叉树

给定一个二叉树，判断它是否是高度平衡的二叉树。

本题中，一棵高度平衡二叉树定义为：一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1 。

自顶向下：

有了计算节点高度的函数，即可判断二叉树是否平衡。具体做法类似于二叉树的前序遍历，即对于当前遍历到的节点，首先计算左右子树的高度，如果左右子树的高度差是否不超过 1，再分别递归地遍历左右子节点，并判断左子树和右子树是否平衡。这是一个自顶向下的递归的过程。

    public static boolean isBalanced(TreeNode root) {
        if (root == null){
            return true;
        }
        //返回用且（&&）是因为都true才能返回true，只要有一个为false就返回false
        //最终返回结果等于：当前root的左右高度差是否小于1&&当前节点的左子树是否平衡&&当前节点的右子树是否平衡
        return Math.abs(getHeigh(root.left) - getHeigh(root.right)) <= 1 
            && isBalanced(root.left) && isBalanced(root.right);

    }

    private static int getHeigh(TreeNode root){
        int heighL,heighR;
        if (root != null){
            heighL = getHeigh(root.left);
            heighR = getHeigh(root.right);
            return Math.max(heighL,heighR) + 1;
        }
        return 0;
    }

自底向上：

方法一由于是自顶向下递归，因此对于同一个节点，函数 getHeigh会被重复调用，导致时间复杂度较高。如果使用自底向上的做法，则对于每个节点，函数getHeigh 只会被调用一次。

自底向上递归的做法类似于后序遍历，对于当前遍历到的节点，先递归地判断其左右子树是否平衡，再判断以当前节点为根的子树是否平衡。如果一棵子树是平衡的，则返回其高度（高度一定是非负整数），否则返回 −1。如果存在一棵子树不平衡，则整个二叉树一定不平衡。

   public static boolean isBalanced(TreeNode root){
        return getheight(root)!=-1;
    }

    private static int getheight(TreeNode root) {
        if (root==null)return 0;
        int left=getheight(root.left);
        if (left==-1)return -1;
        int right=getheight(root.right);
        if (right==-1)return -1;
        if (Math.abs(left-right)>1)return -1;
        return Math.max(left,right)+1;
    }

六、对称二叉树

给定一个二叉树，检查它是否是镜像对称的。

递归：

我们将根节点的左子树记做 left，右子树记做 right。比较 left 是否等于 right，不等的话直接返回就可以了。
如果相等，比较 left 的左节点和 right 的右节点，再比较 left 的右节点和 right 的左节点
比如看下面这两个子树(他们分别是根节点的左子树和右子树)，能观察到这么一个规律：
左子树 22 的左孩子 == 右子树 22 的右孩子
左子树 22 的右孩子 == 右子树 22 的左孩子

    public static boolean isSymmetric(TreeNode root) {
        if (root == null)return true;
        return checkEqual(root.left,root.right);
    }

    private static boolean checkEqual(TreeNode root1,TreeNode root2){
        if (root1 == null && root2 == null){//如果两个节点都是null
            return true;
        }
        if (root1 == null ^ root2 == null){//一个为null，一个不为null
            return false;
        }
        //走到这root1和root2都不等于null
        if (root1.val != root2.val){
            return false;
        }
        //都真才返回真
        return checkEqual(root1.left,root2.right) && checkEqual(root1.right,root2.left);
    }

七、二叉树的层序遍历

给你一个二叉树，请你返回其按 层序遍历 得到的节点值。 （即逐层地，从左到右访问所有节点）。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lbpIb2fv-1626578300309)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210714104727534.png)]

思路：利用BFS广度优先搜索的方法来进行遍历。但是普通的BFS遍历二叉树是没有区分层次的，只是按照二叉树的层次从上到下打印出来。本题增加的要求是除了按照层次顺序遍历打印，还要把同一层的节点值放在同一个list中。因此，我们需要两个队列来完成，也就是把每一层处理完后，把他的左右子节点放到另一个队列，这样子就可以把不同层次的节点分开；或者用一个队列，但是要记录当前层次的个数，只对这部分个数的节点进行处理。

两个队列：

 public static List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> result = new ArrayList<>();
        if (root == null){
            return result;
        }
        Queue<TreeNode> queue1 = new LinkedList<>();
        Queue<TreeNode> queue2 = new LinkedList<>();
        queue1.offer(root);
        while (!(queue1.isEmpty() && queue2.isEmpty())){
            if (queue1.isEmpty()){
                ArrayList<Integer> tmp = new ArrayList<>();
                while (!queue2.isEmpty()){
                    TreeNode curNode = queue2.poll();
                    if (curNode.left != null){
                        queue1.offer(curNode.left);
                    }
                    if (curNode.right != null){
                        queue1.offer(curNode.right);
                    }
                    tmp.add(curNode.val);
                }
                result.add(tmp);
            }else if (queue2.isEmpty()){
                ArrayList<Integer> tmp = new ArrayList<>();
                while (!queue1.isEmpty()){
                    TreeNode curNode = queue1.poll();
                    if (curNode.left != null){
                        queue2.offer(curNode.left);
                    }
                    if (curNode.right != null){
                        queue2.offer(curNode.right);
                    }
                    tmp.add(curNode.val);
                }
                result.add(tmp);
            }
        }
        return result;
    }

一个队列：

public List<List<Integer>> levelOrder(TreeNode root) {
    List<List<Integer>> res = new ArrayList<>();

    Queue<TreeNode> queue = new ArrayDeque<>();
    if (root != null) {
        queue.add(root);
    }
    while (!queue.isEmpty()) {
        int n = queue.size();
        List<Integer> level = new ArrayList<>();
        for (int i = 0; i < n; i++) { 
            TreeNode node = queue.poll();
            level.add(node.val);
            if (node.left != null) {
                queue.add(node.left);
            }
            if (node.right != null) {
                queue.add(node.right);
            }
        }
        res.add(level);
    }

    return res;
}

[补充：BFS适用两个场景：「层序遍历」、「最短路径」]

八、从前序与中序遍历序列构造二叉树

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-M2yH9LpY-1626578300312)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210714185519281.png)]

    public static TreeNode buildTree(int[] preorder, int[] inorder) {
        HashMap<Integer,Integer> hashIn = hashIn = new HashMap<>();
        int len = preorder.length;
        for (int i = 0;i < len;i++){
            hashIn.put(inorder[i],i);
        }
        return build(preorder,inorder,0,len - 1,0,len - 1,hashIn);
    }

    private static TreeNode build(int[] preorder, int[] inorder,int preLeft,int preRight,int inLeft,int inRight,HashMap<Integer,Integer> hashIn){
        if (preLeft > preRight || inLeft > inRight)return null;//递归终止条件

        int preRoot = preLeft;//前序遍历根节点位置
        int pIndex = hashIn.get(preorder[preRoot]);//根节点对应中序遍历的位置

        //先建立根节点
        TreeNode root = new TreeNode(preorder[preRoot]);
        //得到左子树的节点数目=根节点中序遍历的位置 - inleft
        int sizeLeft = pIndex - inLeft;
        //递归构造左子树，并连接到根节点
        root.left = build(preorder,inorder,preLeft + 1,preLeft + sizeLeft,inLeft,pIndex - 1,hashIn);
        //递归构造右子树，并连接到根节点
        root.right = build(preorder,inorder,preLeft + sizeLeft + 1,preRight,pIndex + 1,inRight,hashIn);
        return root;
    }

数目=根节点中序遍历的位置 - inleft
int sizeLeft = pIndex - inLeft;
//递归构造左子树，并连接到根节点
root.left = build(preorder,inorder,preLeft + 1,preLeft + sizeLeft,inLeft,pIndex - 1,hashIn);
//递归构造右子树，并连接到根节点
root.right = build(preorder,inorder,preLeft + sizeLeft + 1,preRight,pIndex + 1,inRight,hashIn);
return root;
}