代码随想录Day14：二叉树（翻转二叉树、对称二叉树、二叉树的最大深度、二叉树的最小深度——全递归版本）

一、实战

226翻转二叉树

思路：其实就是交换每一个节点的左右孩子。按顺序遍历所有节点之后进行左右孩子交换

递归方法

递归方法有一个注意点，就是中序遍历不行，前序后序都可以。

为什么中序不行？

本质原因是前后序的根节点都在边上，我们做节点交换处理就是在根节点上处理。但是中序遍历试想一下，前把左子树各种交换完成之后，然后根节点交换左右子树，此时之前的左子树变成右子树，然后对右子树进行重复处理，那就不对了、

package org.example.Tree;

public class invertTree226 {
    //递归，前序遍历后序遍历都可以，中序不可以
    //这是前序版本
    public TreeNode invertTree(TreeNode root) {
        //root为空的情况
        if (root == null) {return null;}

        preorder(root);
        return root;
    }
    
    private void preorder(TreeNode root) {
        if(root==null) return;

        TreeNode temp;
        temp=root.left;
        root.left=root.right;
        root.right=temp;

        preorder(root.left);
        preorder(root.right);

    }

    public static void main(String[] args) {

    }
}

101对称二叉树

101. 对称二叉树 - 力扣（LeetCode）

思路：此题比较的是两个子树的里侧和外侧的元素是否相等。因为要遍历两棵树而且要比较内侧和外侧节点，所以准确的来说是一个树的遍历顺序是左右中，一个树的遍历顺序是右左中。但都可以理解算是后序遍历，尽管已经不是严格上在一个树上进行遍历的后序遍历了。

确定遍历顺序，此题只能使用后序，只有后序才能把底部孩子节点的信息返回给上一层，根节点才能进行判断。

package org.example.Tree;

public class isSymmetric101 {
    //递归法
    public boolean isSymmetric(TreeNode root) {
        if(root==null) return true;
        return compare(root.left,root.right);
    }

    private 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.val != right.val) return false;

        //左右节点都不为空，且数值相同的情况
        boolean outside=compare(left.left,right.right);
        boolean inside=compare(left.right,right.left);
        return outside&&inside;

    }

    public static void main(String[] args) {

    }
}

104二叉树的最大深度

104. 二叉树的最大深度 - 力扣（LeetCode）

思路：首先分清楚概念，深度（任意一个节点到根节点的距离，从1开始），高度（任意一个节点到叶子结点的距离，从1开始）。

求深度用前序（根左右）遍历，中是处理过程

求高度用后序（左右根）遍历，因为后序子节点可以吧当前高度返回给父节点，父节点加一即可。

根节点高度=二叉树最大深度

为什么前序遍历可以求二叉树最大深度，而中序不可以？通义大模型-参考

前序遍历按照“根-左-右”的顺序访问节点。这意味着你首先访问根节点，然后递归地对左子树进行前序遍历，最后递归地对右子树进行前序遍历。当你尝试用前序遍历来计算最大深度时，你可以通过一个额外的参数来记录当前节点的深度，并在每次递归调用时更新这个值。这样，在遍历过程中，你可以轻松地跟踪并更新遇到的最大深度。因此，前序遍历可以用来求二叉树的最大深度。

相比之下，中序遍历遵循的是“左-根-右”的访问顺序。这种方法首先完全遍历左子树，然后访问根节点，最后遍历右子树。这种遍历方式本身并不提供任何关于树的高度或从根到当前节点路径长度的信息，因为直到你到达某个节点的最左端之前，你都无法知道你已经向下走了多深。此外，由于它在访问根节点之前先访问其左子树，且在访问根节点之后再访问其右子树，这使得仅使用中序遍历难以直接追踪从根节点到当前节点的路径长度，从而难以直接从中计算出最大深度。

方法1：高度-后序

package org.example.Tree;

public class maxDepth104 {
    //高度-后序
    public int maxDepth(TreeNode root) {
        return getDeep(root);
    }

    private int getDeep(TreeNode root) {
        if(root==null)return 0;//叶子节点，高度0
        int left_deep=getDeep(root.left);// 左
        int right_deep=getDeep(root.right);// 右

        //处理
        return 1+Math.max(left_deep,right_deep);
    }

    public static void main(String[] args) {

    }
}

方法2：深度-前序

package org.example.Tree;

public class maxDepth104f2 {
    int result;
    public int maxDepth(TreeNode root) {
        result=0;
        if (root == null) return result;
        getDeep(root,1);
        return result;
    }

    private void getDeep(TreeNode root, int i) {
        //根节点处理，两句顺序不能换，深度需要立刻更新
        result=Math.max(i,result);
        if(root.left==null&&root.right==null) return;

        if(root.left!=null) getDeep(root.left,i+1);
        if(root.right!=null) getDeep(root.right,i+1);

    }
}

111二叉树的最小深度

111. 二叉树的最小深度 - 力扣（LeetCode）

直觉上好像和求最大深度差不多，其实还是差不少的。本题依然是前序遍历和后序遍历都可以，前序求的是深度，后序求的是高度。

求深度用前序（根左右）遍历，中是处理过程

求高度用后序（左右根）遍历，因为后序子节点可以吧当前高度返回给父节点，父节点加一即可。

重点：最小深度是根节点到叶子结点的最小距离。

方法1：高度-后序

package org.example.Tree;

public class minDepth111 {
    //高度-后序
    public int minDepth(TreeNode root) {
        return getDeep(root);
    }

    private int getDeep(TreeNode root) {
        if(root==null)return 0;//叶子节点，高度0
        int left_deep=getDeep(root.left);// 左
        int right_deep=getDeep(root.right);// 右

        //处理
        //错误写法直接一句return 1+Math.min(left_deep,right_deep);直接让没有孩子的分支是最短深度了
        //当一个左子树为空，右不为空，这时并不是最低点
        if (root.left==null&& root.right!=null) {
            return 1 + right_deep;
        }
        //当一个右子树为空，左不为空，这时并不是最低点
        if (root.right==null&& root.left!=null) {
            return 1 + left_deep;
        }
        //当一个右左都不为空，才能这么判断
        return 1+Math.min(left_deep,right_deep);
    }

    public static void main(String[] args) {

    }
}

方法2：深度-前序

与后序遍历不同，前序遍历可以一直遍历到底部，也就是只要节点不是叶子节点，就算一边没有孩子，但是只要有子节点就能继续走下去，不用加if判断这种情况，只在遇到真正的叶子节点时才更新 result。

package org.example.Tree;

public class minDepth111f2 {
    int result;
    public int minDepth(TreeNode root) {
        result=Integer.MAX_VALUE;;
        if (root == null) return 0;
        getDeep(root,1);
        return result;
    }

    private void getDeep(TreeNode root, int i) {
        //根节点处理，只有是叶子节点的时候需要min处理
        if(root.left==null&&root.right==null)
        {
            result=Math.min(i,result);
            return;
        }

        if(root.left!=null) getDeep(root.left,i+1);
        if(root.right!=null) getDeep(root.right,i+1);

    }
}