leetcode-12-[226]翻转二叉树[101]对称二叉树[104]二叉树的最大深度[111]二叉树的最小深度

前置知识：

深度：任意节点到根节点的节点数

高度：任意节点到叶子节点（左右孩子都为空）的节点数

一、[226]翻转二叉树

重点：交换节点应该传入根节点

class Solution {
    public TreeNode invertTree(TreeNode root) {
        if(root==null)
            return root;
        //前序遍历
        swap(root);
        invertTree(root.left);
        invertTree(root.right);
        return root;
    }
    //交换注意一下
    void swap(TreeNode root){
        TreeNode tmp=root.left;
        root.left=root.right;
        root.right=tmp;
    }
}

二、[101]对称二叉树

class Solution {
    public boolean isSymmetric(TreeNode root) {
        //后序遍历
        //左右节点的信息返回给根节点
        return compare(root.left,root.right);
    }
    boolean compare(TreeNode left,TreeNode right){
        if(left==null&&right==null){
            return true;
        }
        if(left==null&&right!=null){
            return false;
        }
        if(left!=null&&right==null){
            return false;
        }
        //注意一下
        if(left.val!=right.val){
            return false;
        }
        boolean r1 = compare(left.left, right.right);
        boolean r2 = compare(left.right, right.left);
        if(r1&&r2){
            return true;
        }else{
            return false;
        }
    }
}

三、[104]二叉树的最大深度

class Solution {
    int max=0;
    public int maxDepth(TreeNode root) {
         depth(root,0);
         return max;
    }
    void depth(TreeNode node,int tmp){
        if(node==null)
            return;
        tmp++;
        max= Math.max(tmp, max);
        depth(node.left,tmp);
        depth(node.right,tmp);
    }
}

四、[111]二叉树的最小深度

后序遍历

注意：

1、题目中：最小深度是从根节点到最近叶子节点的最短路径上的节点数量。

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

2、tmp为局部变量，不存值，直观来说，即层层递归之后的返回tmp，仍为一开始传入的tmp,中间过程忽略不计。

class Solution {
    int min=Integer.MAX_VALUE;
    public int minDepth(TreeNode root) {
        depth(root,0);
        return min==Integer.MAX_VALUE?0:min;
    }
    void depth(TreeNode node,int tmp){
        if(node==null){
            return;
        }
        tmp++;
        depth(node.left,tmp);
        depth(node.right,tmp);
        if(node.left==null&&node.right==null){
            min=Math.min(min,tmp);
        }
    }
}