day16 104.二叉树的最大深度 111. 二叉树的最小深度 222.完全二叉树的节点个数

文档讲解：代码随想录（代码随想录）

完成状态:  true

                 这三道题主要是对层序遍历的回顾，思路都很简单。

104.二叉树的最大深度

                使用层序遍历解决。

class Solution {
    public int maxDepth(TreeNode root) {
        if(root == null){
            return 0;
        }
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        queue.offer(root);

        int high = 0;
        while(!queue.isEmpty()){
            int length = queue.size();
            while(length > 0){
                TreeNode node = queue.poll();
                if(node.left != null){
                    queue.offer(node.left);
                }
                if(node.right != null){
                    queue.offer(node.right);
                }
                length--;
            }
            high++;
        }
        return high;
    }
}

111. 二叉树的最小深度

        同样使用层序遍历来解决，需要注意的是明确什么是最小深度。最小深度是从根节点到最近叶子节点的最短路径上的节点数量。注意是叶子节点。叶子节点是左右孩子都为空的节点才是叶子节点！

class Solution {
    public int minDepth(TreeNode root) {
        if(root == null){
            return 0;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);

        int depth = 0;
        while(!queue.isEmpty()){
            depth++;
            int length = queue.size();
            while(length > 0){
                TreeNode node = queue.poll();
                if(node.left != null){
                    queue.offer(node.left);
                }
                if(node.right != null){
                    queue.offer(node.right);
                }
                if(node.left == null && node.right == null){
                    return depth;  // 叶子节点是左右节点都为空
                }
                length--;
            }
        }
        return depth;
    }
}

222.完全二叉树的节点个数

 迭代法： 层序遍历每一层，对每一层的节点个数做累加即可。

class Solution {
    public int countNodes(TreeNode root) {
        if(root == null){
            return 0;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        int depth = 0, num = 0;
        while(!queue.isEmpty()){
            depth++;
            int length = queue.size();
            num += length;
            while(length > 0){
                TreeNode node = queue.poll();
                if(node.left != null){
                    queue.offer(node.left);
                }
                if(node.right != null){
                    queue.offer(node.right);
                }
                length--;
            }
        }
        return num;
    }
}

递归法：

        方法1：

                按照普通二叉树来计算二叉树的节点个数：后序遍历，左子树的节点个数+右子树的节点个数+根节点

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

        方法2：

                利用完全二叉树的特性来解决问题。在完全二叉树中，若左子树的深度=右子树的深度，则以该节点为根节点的二叉树一定是满二叉树。

                知道了这个，我们就可以加快方法一的计算速度，避免遍历一些不必要的节点，并不需要遍历所有的节点。如当判断根节点的左子树的二叉树是满二叉树就可以直接使用公式计算其节点个数，并返回给根节点，此时根节点只需去计算右子树的节点个数即可，相当于提前结束方法一的递归一样(不需要像方法一一样继续递归遍历完左子树的每个节点，再去遍历右子树)。当不是满二叉树时，则继续递归遍历，直到找到一个满二叉树(叶子节点一定是满二叉树)就可以返回。 

class Solution {
    public int countNodes(TreeNode root) {
        // 终止条件1:节点为空
        if(root == null){
            return 0;
        }
        // 终止条件2：节点下为满二叉树
        int leftLength = 0, rightLength = 0;
        TreeNode left = root.left;
        TreeNode right = root.right;
        while(left != null){
            left = left.left;
            leftLength++;
        }
        while(right != null){
            right = right.right;
            rightLength++;
        }
        if(leftLength == rightLength){
            return (2 << leftLength) - 1; // leftLength = 1时， 2 << 1表示2的2次方。
        }

        // 如果不满足上述终止条件
        int leftNum = countNodes(root.left); // 左
        int rightNum = countNodes(root.right); // 右
        return leftNum + rightNum + 1; // 根
    }
}