leetcode刷题day14|二叉树Part02（以递归方法为主：226.翻转二叉树、101. 对称二叉树、104.二叉树的最大深度、111.二叉树的最小深度）-CSDN博客

本文链接：https://blog.csdn.net/m0_51007517/article/details/142150101

226.翻转二叉树

思路：利用先序遍历递归翻转
1、终止条件：节点为空，return
2、参数：root
3、递归函数逻辑：处理中间节点，交换；递归左孩子，递归右孩子
代码如下：

class Solution {
    public TreeNode invertTree(TreeNode root) {
        if(root==null) return root;
        swapChildren(root);
        invertTree(root.left);
        invertTree(root.right);
        return root;
    }
    public void swapChildren(TreeNode root){
        TreeNode temp=root.left;
        root.left=root.right;
        root.right=temp;
    }
}

101. 对称二叉树

思路：考察根节点下的两棵树是否对称。思考了一下该题只能使用后序遍历，一棵树的遍历顺序是左右中，另一颗是右左中。
1、传入参数：左孩子，右孩子；返回值bool类型
2、终止条件：左孩子为空，右孩子不为空return false；
左孩子不为空，右孩子为空return false；
左孩子为空，右孩子为空，return true；
左孩子不为空，右孩子不为空，左孩子.val不等于右孩子.val，return false；
剩下一种情况进一步递归判断。
3、递归逻辑：递归调用（左孩子的左孩子，右孩子的右孩子）&&递归调用（左孩子的右孩子，右孩子的左孩子）。
代码如下：

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

104.二叉树的最大深度

后序遍历递归

思路：1、传入参数：root，返回值类型：int；2、终止条件：如果节点为空，返回0；3、递归逻辑：判断左孩子的深度（递归）和右孩子深度谁更大，最大深度为大的+1。
代码：

class Solution {
    public int maxDepth(TreeNode root) {
        if(root==null) return 0;
        int leftDepth=maxDepth(root.left);//左
        int rightDepth=maxDepth(root.right);//右
        return Math.max(leftDepth,rightDepth)+1;//中
    }
}

先序遍历递归

设置全局变量记录深度1、传入参数：root、deep，无返回值；2、终止条件：如果节点为空，返回；3、递归逻辑：在节点不为空的情况下，deep层数+1；判断深度和全局变量的大小，取大值；计算左孩子的深度（递归）；计算右孩子的深度。
代码：

class Solution {
    int maxNum=0;
    public int maxDepth(TreeNode root) {
        preMax(root,0);
        return maxNum;
    }
    public void preMax(TreeNode root,int deep){
        if(root==null) return;
        deep++;//节点存在，层数+1
        maxNum=maxNum>deep? maxNum: deep;//中
        preMax(root.left,deep);
        preMax(root.right,deep);
    }
}

层次遍历递归

思路：通过每一层队列的元素数量来遍历每一层，使用全局变量deep对层数计数。

class Solution {
    public int maxDepth(TreeNode root) {
        if(root==null) return 0;
        Queue<TreeNode> queue=new LinkedList<>();
        int deep=0;
        queue.offer(root);
        while(!queue.isEmpty()){
            int size=queue.size();
            deep++;
            for(int i=0;i<size;i++){
                TreeNode node=queue.poll();
                if(node.left!=null) queue.offer(node.left);
                if(node.right!=null) queue.offer(node.right);
            }
        }
        return deep;
    }
}

111.二叉树的最小深度

注意：求二叉树的最小深度和求二叉树的最大深度的差别主要在于处理左右孩子一个为空一个不为空的逻辑。当节点的左右孩子一个为空一个不为空时不能说这个节点为叶子节点。
思路：思路：1、传入参数：root，返回值类型：int；2、终止条件：如果节点为空，返回0；3、递归逻辑：判断左孩子的深度（递归），右孩子深度。如果节点的左子树为空，右子树不为空，返回右子树深度+1；如果左子树不为空，右子树为空，返回左子树深度+1；如果均不为空，返回左右子树深度更小的+1。
代码如下：

class Solution {
    public int minDepth(TreeNode root) {
        if(root==null) return 0;
        int leftDepth=minDepth(root.left);
        int rightDepth=minDepth(root.right);
        if(root.left==null && root.right!=null) return rightDepth+1;
        else if(root.left!=null && root.right==null) return leftDepth+1;
        else return Math.min(leftDepth,rightDepth)+1;
    }
}