玩转二叉树常考题 最大最小深度 翻转二叉树 判断二叉树对称 完全二叉树节点个数（3.29在思考思考） 判断平衡二叉树（返回深度 ，看是不是-1））

求二叉树最小深度 递归

class Solution {
    public int minDepth(TreeNode root) {
        if(root==null) return 0;
        return helper(root);
        
    }  
    public int helper(TreeNode root){
        if(root==null) return Integer.MAX_VALUE;//因为是最小深度 不能返回0
        if(root.left==null && root.right==null) return 1;
        return Math.min(helper( root.right),helper(root.left))+1;
    }
}

一行代码解决：

class Solution {
    public int maxDepth(TreeNode root) {
        return root == null ? 0 : Math.max(maxDepth(root.left), maxDepth(root.right)) + 1;
    }
}

反转二叉树

3.29自己写的

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

别人写的

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

    }
}

另一种写法：

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

    }
}

判断二叉树对称

自己3.29 写的

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public boolean isSymmetric(TreeNode root) {
        if(root==null) return true;
        return helper(root,root);
    }
    private boolean helper(TreeNode left,TreeNode right){
        if(right==null && left==null) return true;
        if(right==null || left==null) return false;
        if(left.val!=right.val) return false;
        return helper(left.left,right.right) && helper(left.right,right.left);
    }
}

递归

要把几个情况都想出来 false 的 true 的

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

时间复杂度：O(n)，因为我们遍历整个输入树一次，所以总的运行时间为 O(n)，其中 n是树中结点的总数。
空间复杂度：递归调用的次数受树的高度限制。在最糟糕情况下，树是线性的，其高度为 O(n)。因此，在最糟糕的情况下，由栈上的递归调用造成的空间复杂度为 O(n)。

迭代

队列中每两个连续的结点应该是相等的，而且它们的子树互为镜像。
最初，队列中包含的是 root 以及 root。
该算法的工作原理类似于 BFS，但存在一些关键差异。每次提取两个结点并比较它们的值。
然后，将两个结点的左右子结点按相反的顺序插入队列中。当队列为空时，或者我们检测到树不对称（即从队列中取出两个不相等的连续结点）时，该算法结束。

public boolean isSymmetric(TreeNode root) {
    Queue<TreeNode> q = new LinkedList<>();
    q.add(root);
    q.add(root);
    while (!q.isEmpty()) {
        TreeNode t1 = q.poll();
        TreeNode t2 = q.poll();
        if (t1 == null && t2 == null) continue;
        if (t1 == null || t2 == null) return false;
        if (t1.val != t2.val) return false;
        q.add(t1.left);
        q.add(t2.right);
        q.add(t1.right);
        q.add(t2.left);
    }
    return true;
}

思考：先判断 ，后添加，成对成对添加

求二叉树节点个数

给出一个完全二叉树，求出该树的节点个数。

说明：
完全二叉树的定义如下：在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。若最底层为第 h 层，则该层包含 1~ 2h 个节点。
示例:
输入:
1
/
2 3
/ \ /
4 5 6

普通二叉树递归求个数

class Solution {
    public int countNodes(TreeNode root) {
        if(root==null) return 0;
        int left=countNodes(root.left);
        int right=countNodes(root.right);
        return 1+left+right;
    }
}

以上方法容易理解但是没有利用完全二叉树的特点

巧方法（3.29再思考思考）

首先需要明确完全二叉树的定义：它是一棵空树或者它的叶子节点只出在最后两层，若最后一层不满则叶子节点只在最左侧。

再来回顾一下满二叉的节点个数怎么计算，如果满二叉树的层数为h，则总节点数为：2^h - 1.
那么我们来对root节点的左右子树进行高度统计，分别记为left和right,有以下两种结果：

1. left == right。这说明，左子树一定是满二叉树，因为节点已经填充到右子树了，左子树必定已经填满了。所以左子树的节点总数我们可以直接得到，是2^left - 1，加上当前这个root节点，则正好是2^left。再对右子树进行递归统计。
2. left != right。说明此时最后一层不满，但倒数第二层已经满了，可以直接得到右子树的节点个数。同理，右子树节点+root节点，总数为2^right。再对左子树进行递归查找。
   关于如何计算二叉树的层数，可以利用下面的递归来算，当然对于完全二叉树，可以利用其特点，不用递归直接算，具体请参考最后的完整代码。

如何计算2^left，最快的方法是移位计算，因为运算符的优先级问题，记得加括号哦。

class Solution {
    public int countNodes(TreeNode root) {
        if(root==null) return 0;
        int left=countLevel(root.left);
        int right=countLevel(root.right);
        if(left==right) {
            return countNodes(root.right)+(1<<left);
        }else
            return countNodes(root.left)+(1<<right);
    }
    public int countLevel(TreeNode root){
        int level=0;
        while(root!=null){
            level++;
            root=root.left;
        }
        return level;
    }
}
/*

判断平衡二叉树

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

本题中，一棵高度平衡二叉树定义为：

一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过1。

示例 1:

给定二叉树 [3,9,20,null,null,15,7]

3

/
9 20
/
15 7
返回 true 。

递归

从底至顶（提前阻断法）
对二叉树做深度优先遍历DFS，递归过程中：
终止条件：当DFS越过叶子节点时，返回高度0；
返回值：
从底至顶，返回以每个节点root为根节点的子树最大高度(左右子树中最大的高度值加1max(left,right) + 1)；
当我们发现有一例 左/右子树高度差 ＞ 1 的情况时，代表此树不是平衡树，返回-1；
当发现不是平衡树时，后面的高度计算都没有意义了，因此一路返回-1，避免后续多余计算。
最差情况是对树做一遍完整DFS，时间复杂度为 O(N)。

class Solution {
    public boolean isBalanced(TreeNode root) {
        return depth(root) != -1;
    }

    private int depth(TreeNode root) {
        if (root == null) return 0;
        int left = depth(root.left);
        if(left == -1) return -1;
        int right = depth(root.right);
        if(right == -1) return -1;
        return Math.abs(left - right) < 2 ? Math.max(left, right) + 1 : -1;
    }
}

class Solution {
    public boolean isBalanced(TreeNode root) {
        return depth(root)!=-1;
    }
    public int depth(TreeNode root){
        if(root==null) return 0;
        int left=depth(root.left);
        int right=depth(root.right);
        if(left==-1) return -1;
        if(right==-1) return -1;
        if(Math.abs(left-right)<2) 
            return Math.max(left,right)+1;
        else    
            return -1;
    }
}
/*