二叉树的翻转

226.翻转二叉树

题目链接/文章讲解/视频讲解：https://programmercarl.com/0226.%E7%BF%BB%E8%BD%AC%E4%BA%8C%E5%8F%89%E6%A0%91.html

这题使用递归没有特别复杂的逻辑，只是需要注意一点就是这个二叉树的遍历顺序

public TreeNode invertTree(TreeNode root) {
    if(root == null) return root;
	// 这个解法使用的就是前序遍历：中左右，后序也是可以的
    // 为什么使用中序遍历就不可以
	// 因为当我们使用中序遍历时，会先把左孩子交换
    // 当我们把左孩子交换到右边之后，当前的右孩子就是交换后的左孩子，那么这个节点又会被翻转一次
    // 中
    TreeNode node = root.left;
    root.left = root.right;
    root.right = node;
    // 左
    invertTree(root.left);
    // 右
    invertTree(root.right);
    return root;
}

101.对称二叉树

题目链接/文章讲解/视频讲解：https://programmercarl.com/0101.%E5%AF%B9%E7%A7%B0%E4%BA%8C%E5%8F%89%E6%A0%91.html

public boolean isSymmetric(TreeNode root) {
    return compare(root.left,root.right);
}

public boolean compare(TreeNode left, TreeNode right){
    // 终止条件
    // 1.左为空，右不为空
    // 2.右为空，左不为空
    // 3.左右都为空，就表示二叉树是对称
    // 4.左右都不为空则判断值是否相等，相等则继续遍历，直到满足前3个中的一个
    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);
    // 最后处理中间节点
    // 逻辑：因为遍历的过程中已经判断值是否相等了
    // 所以这里只要当前节点的左右孩子与右边的树的当前节点的左右孩子都是对称且相等的（例：最后一层（3，4，4，3））
    // 那么就可以告诉节点2你的孩子节点是可以翻转的，那么我们才可以继续向上处理
    return outside && inside;
}

104.二叉树的最大深度

题目链接/文章讲解/视频讲解： https://programmercarl.com/0104.%E4%BA%8C%E5%8F%89%E6%A0%91%E7%9A%84%E6%9C%80%E5%A4%A7%E6%B7%B1%E5%BA%A6.html

// 解法一：使用层序遍历
public int maxDepth(TreeNode root) {
    if(root==null) return 0;
    Queue<TreeNode> q = new LinkedList<>();
    int high=0;
    q.add(root);
    while(!q.isEmpty()){
        // size用来记录当前层的元素数量
        // 所以只要size为0一次，我们就可以把深度+1
        int size = q.size();
        while(size!=0){
            TreeNode cur = q.poll();
            if(cur.left!=null) q.add(cur.left);
            if(cur.right!=null) q.add(cur.right);
            size--;
        }
        high++;
    }
    return high;
}


// 解法二：使用后序遍历进行递归
public int maxDepth(TreeNode root) {
    return getHigh(root);
}

public int getHigh(TreeNode root){
    if(root==null) return 0;
    int leftHigh = getHigh(root.left);
    int rightHigh = getHigh(root.right);

    return Math.max(leftHigh,rightHigh)+1;
}

111.二叉树的最小深度

题目链接/文章讲解/视频讲解：https://programmercarl.com/0111.%E4%BA%8C%E5%8F%89%E6%A0%91%E7%9A%84%E6%9C%80%E5%B0%8F%E6%B7%B1%E5%BA%A6.html

// 解法一：使用层序遍历
public int minDepth(TreeNode root) {
    if(root == null) return 0;
    Queue<TreeNode> q = new LinkedList<>();
    q.add(root);
    // 注意这里深度是从1开始
    // 因为如果根节点的左右孩子都为null，那么代码中的high++就不会执行直接就返回了
    // 但是根节点也是有深度的等于1，所以初始化的时候可以直接赋值
    int high = 1;
    while(!q.isEmpty()){
        int size = q.size();
        while(size!=0){
            TreeNode cur = q.poll();
            if(cur.left!=null) q.add(cur.left);
            if(cur.right!=null) q.add(cur.right);
            if(cur.left==null && cur.right==null) return high;
            size--;
        }
        high++;
    }
    return high;
}




// 使用后序进行递归
public int minDepth(TreeNode root) {
    return getHigh(root);
}

public int getHigh(TreeNode node){
    if(node == null) return 0;

    int leftHigh = getHigh(node.left);
    int rightHigh = getHigh(node.right);

    // 处理左子树为空的情况
    if(node.left==null&&node.right!=null) return 1+rightHigh;
    // 处理右子树为空的情况
    if(node.right==null&&node.left!=null) return 1+leftHigh;
    return Math.min(leftHigh,rightHigh)+1;
}