关于二叉树深度问题

1.二叉树的最大深度

1.1前序遍历

如图分析

 对于node（3），其最大深度是 1 + max（leftNode，rightNode），就是根节点的最大深度取决于左右孩子节点的最大深度，持续迭代可以得出根节点的最大深度

第一张图， 对于node（3),最大深度是 1 + max（node（9），node（20）），而node（20）的最大深度是1 + max（node（15），node（7））

/**
     * 返回二叉树的最大深度(前序遍历)
     * @param root
     * @return
     */
    public int getMaxLength(TreeNode root){
        if (root == null){
            return 0 ;
        }
        int left = getMaxLength(root.leftNode);
        int right = getMaxLength(root.rightNode);
        return 1 + Math.max(left,right);
    }

1.2层次遍历

/**
     * 层次遍历 获取二叉树的深度
     * @param root
     * @return
     */
    public int getMaxLengthByLayer(TreeNode root){
        if (root == null){
            return -1;
        }
        Queue<TreeNode> queue = new ArrayDeque<>();
        queue.add(root);
        int res = 0 ;//记录层数，即深度
        while (!queue.isEmpty()){
            int size = queue.size();//每层的元素个数
            while (size > 0){
                TreeNode removeNode = queue.poll();
                if (removeNode.rightNode != null){
                    queue.add(removeNode.leftNode);
                }
                if (removeNode.rightNode != null){
                    queue.add(removeNode.rightNode);
                }
                size--;
            }
            res++;
        }
        return res;
    }

2.判断平衡二叉树

什么是平衡树：每个节点的左右孩子高度之差不超过1

 /**
     * 判断是否平衡二叉树(后序遍历)
     * 否则返回-1
     * 是则返回平衡二叉树的最大高度
     * @param root
     * @return
     */
    public int getHeight(TreeNode root){
        if (root == null){
            return 0;
        }
        int leftHeight = getHeight(root.leftNode);
        if (leftHeight == -1){
            return -1;
        }
        int rightHeight = getHeight(root.rightNode);
        if (rightHeight == -1){
            return -1;
        }
        int res;//记录最大高度
        if (Math.abs(leftHeight - rightHeight)>1){
            return -1;
        }else {
            res = 1 + Math.max(leftHeight,rightHeight);
        }
        return res;
    }


    public boolean isBalanceAndJudge(TreeNode root){
        return getHeight(root) >= 0 ;
    }

3.最小深度

最小深度：指的是根节点到最近叶子节点的最短路径的节点数

 /**
     * 获取二叉树的最小深度
     * 最小深度：从根节点到最近叶子节点的最短路径的节点数
     * @param root
     * @return
     */
    public int getMinDepth(TreeNode root){
        if (root == null){
            return 0;
        }
        int leftDepth = getMinDepth(root.leftNode);
        int rightDepth = getMinDepth(root.rightNode);
        //左节点为空
        if (root.leftNode == null){
            return rightDepth + 1 ;
        }
        //右节点为空
        if (root.rightNode == null){
            return leftDepth + 1 ;
        }
        //左右节点都不为null的情况
        return Math.min(leftDepth,rightDepth) + 1;
    }