代码随想录Day 16

104.二叉树的最大深度

给定一个二叉树，找出其最大深度。
二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。
说明: 叶子节点是指没有子节点的节点。

二叉树节点的深度：指从根节点到该节点的最长简单路径边的条数或者节点数（取决于深度从0开始还是从1开始）
二叉树节点的高度：指从该节点到叶子节点的最长简单路径边的条数后者节点数（取决于高度从0开始还是从1开始）

单层递归的逻辑：先求它的左子树的深度，再求右子树的深度，最后取左右深度最大的数值 再+1 就是目前节点为根节点的树的深度。

递归法（后序遍历）

//递归法(后序遍历）
class Solution {
    public int maxDepth(TreeNode root) {
        if(root == null) return 0;
        int leftDepth = maxDepth(root.left); //左
        int rightDepth = maxDepth(root.right); //右
        return Math.max(leftDepth, rightDepth) + 1; //中
    }
}

迭代法（层序遍历）

使用迭代法的话，使用层序遍历是最为合适的，因为最大的深度就是二叉树的层数.

//迭代法（层序遍历）
class Solution {
    public int maxDepth(TreeNode root) {
        if(root == null) return 0;
        Deque<TreeNode> deque = new LinkedList<>();
        deque.offer(root);
        int depth = 0;
        while(!deque.isEmpty()){
            depth++;
            int len = deque.size();
            while(len > 0){
                TreeNode node = deque.poll();
                if(node.left != null){
                    deque.offer(node.left);
                }
                if(node.right != null){
                    deque.offer(node.right);
                }
                len--;
            } 
            
        }
        return depth;
    }
}

111. 二叉树的最小深度

给定一个二叉树，找出其最小深度。
最小深度是从根节点到最近叶子节点的最短路径上的节点数量。
说明：叶子节点是指没有子节点的节点。

最小深度是从根节点到最近叶子节点的最短路径上的节点数量
注意叶子节点，左右孩子都为空的节点才是叶子节点！

所以要注意，如果左右只有一个孩子的情况。
递归逻辑：
如果左子树为空，右子树不为空，说明最小深度是 1 + 右子树的深度；
右子树为空，左子树不为空，最小深度是 1 + 左子树的深度；
最后如果左右子树都不为空，返回左右子树深度最小值 + 1 。

递归法（后序遍历）

//递归法
class Solution {
    public int minDepth(TreeNode root) {
        if(root == null) return 0;
        int leftDepth = minDepth(root.left); //左
        int rightDepth = minDepth(root.right); //右
        //需要对左子树为null或者右子树为null的情况单独处理
        if(root.left == null && root.right != null){
            return rightDepth + 1;
        }
        if(root.left != null && root.right == null){
            return leftDepth + 1;
        }
        return Math.min(leftDepth, rightDepth) + 1; //中
    
    }
}

迭代法解决二叉树的最小深度，依然可以用层序遍历的模板来解决。

需要注意的是，只有当左右孩子都为空的时候，才说明遍历到最低点了。如果其中一个孩子不为空则不是最低点。

迭代法（层序遍历）

//迭代法（层序遍历）
class Solution {
    public int minDepth(TreeNode root) {
        if(root == null) return 0;
        Deque<TreeNode> deque = new LinkedList<>();
        deque.offer(root);
        int depth = 0;
        while(!deque.isEmpty()){
            depth++;
            int len = deque.size();
            while(len > 0){
                TreeNode node = deque.poll();
                // 是叶子结点，直接返回depth，因为从上往下遍历，所以该值就是最小值
                if(node.left == null && node.right == null){
                    return depth;
                }
                if(node.left != null){
                    deque.offer(node.left);
                }
                if(node.right != null){
                    deque.offer(node.right);
                }
                len--;
            }
        }
        return depth;
    
    }
}

求二叉树的最小深度和求二叉树的最大深度的差别主要在于处理左右孩子不为空的逻辑。

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

递归法（后序遍历）

传统的递归法解决这个问题比较简单

确定单层递归的逻辑：先求它的左子树的节点数量，再求右子树的节点数量，最后取总和再加一，就是目前节点为根节点的节点数量。

代码如下：

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

    }
}

考虑利用完全二叉树的特性，用递归法解决这个问题。

完全二叉树只有两种情况，情况一：就是满二叉树，情况二：最后一层叶子节点没有满。

对于情况一，可以直接用 2^树深度 - 1 来计算，注意这里根节点深度为1。

对于情况二，分别递归左孩子，和右孩子，递归到某一深度一定会有左孩子或者右孩子为满二叉树，然后依然可以按照情况1来计算。

关键：如何去判断一个左子树或者右子树是不是满二叉树呢？

在完全二叉树中，如果递归向左遍历的深度等于递归向右遍历的深度，那说明就是满二叉树。

class Solution {
    public int countNodes(TreeNode root) {
        if(root == null) return 0;
        TreeNode leftNode = root.left;
        TreeNode rightNode = root.right;
        int leftDep = 0; //向左遍历的深度
        int rightDep = 0; //向右遍历的深度
        while(leftNode != null){
            leftDep++;
            leftNode = leftNode.left;
        }
        while(rightNode != null){
            rightDep++;
            rightNode = rightNode.right;
        }
        if(leftDep == rightDep){
            return (2 << leftDep) - 1;  // 注意(2<<1) 相当于2^2，所以leftDepth初始为0
        }
        return countNodes(root.left) + countNodes(root.right) + 1;
    }
}

迭代法（层序遍历）

class Solution {
    public int countNodes(TreeNode root) {
        if(root == null) return 0;
        Deque<TreeNode> deque = new LinkedList<>();
        int result = 0;
        deque.offer(root);
        while(!deque.isEmpty()){
            int len = deque.size();
            while(len > 0){
                TreeNode node = deque.poll();
                result++;
                if(node.left != null){
                    deque.offer(node.left);
                }
                if(node.right != null){
                    deque.offer(node.right);
                }
                len--;
            }
        }
        return result;
    }
}