代码随想录第十三天|二叉树的最大深度|二叉树的最小深度|完全二叉树的节点个数

二叉树问题目前的解决方法有三种：递归法、迭代法和层序遍历法。今天的三道题分别使用层序遍历的模版方法和递归法进行解决。

二叉树的最大深度

递归法：这里递归法三要素，返回值，参数列表；终止条件；循环逻辑。这里还有最主要的是选择遍历的方法。因为是找最大深度，可以将左子树和右子树的深度返回给中间节点，适合使用后序遍历。然后对于中间节点的处理逻辑，将左子树和右子树中深度最大的加上1后（这里加一是因为中间节点也占一个位置，算一个深度）进行返回。

class Solution {
    public int maxDepth(TreeNode root) {
        return getheight(root);
    }
    public int getheight(TreeNode node){
        if(node==null){ //终止条件
            return 0;
        }
        //左
        int leftheight=getheight(node.left);
        //右
        int rightheight=getheight(node.right);
        //中
        int height=1+Math.max(leftheight,rightheight);
        return height;
    }
}

层序遍历的代码

class Solution {
    public int maxDepth(TreeNode root) {
        ArrayDeque<TreeNode> queue=new ArrayDeque();
        if(root==null){
            return 0;
        }
        queue.addLast(root);
        int depth=0;
        while(!queue.isEmpty()){
            int size=queue.size();
            while(size>0){
                TreeNode node=queue.poll();
                if(node.left!=null){
                    queue.addLast(node.left);
                }
                if(node.right!=null){
                    queue.addLast(node.right);
                }
                size--;
            }
            depth++;
        }
        return depth;
    }
}

二叉树的最小深度

递归法：这里求最小深度和最大深度有一些区别，这里的最小深度是离根节点最近的叶子节点的深度。不能直接将左子树和右子树中最小深度加一返回，在处理中间节点时需要分情况讨论。

class Solution {
    public int minDepth(TreeNode root) {
        return getmindepth(root);
    }
    public int getmindepth(TreeNode node){
        if(node==null){
            return 0;
        }
        int minleftdepth=getmindepth(node.left);
        int minrightdepth=getmindepth(node.right);
        if(node.left==null&&node.right!=null){
            return 1+minrightdepth;
        }else if(node.left!=null&&node.right==null){
            return 1+minleftdepth;
        }else{
            int mindepth=Math.min(minleftdepth,minrightdepth)+1;
            return mindepth;
        }
        
    }
}

层序遍历

class Solution {
    public int minDepth(TreeNode root) {
        ArrayDeque<TreeNode> queue=new ArrayDeque();
        if(root==null){
            return 0;
        }
        queue.addLast(root);
        int mindepth=1;
        while(!queue.isEmpty()){
            int size=queue.size();
            while(size>0){
                TreeNode node=queue.poll();
                if(node.left==null&&node.right==null){
                    return mindepth;
                }
                if(node.left!=null){
                    queue.addLast(node.left);
                }
                if(node.right!=null){
                    queue.addLast(node.right);
                }
                size--;
            }
            mindepth++;
        }
        return mindepth;
    }
}

完全二叉树的节点数

递归法：这里使用后序遍历，直接统计左子树和右子树的节点数，返回给根节点然后加上根节点本身即可统计出节点数。

class Solution {
    public int countNodes(TreeNode root) {
        return getnodes(root);
    }
    public int getnodes(TreeNode node){
        if(node==null){
            return 0;
        }
        int getleftnodes=getnodes(node.left);
        int getrightnodes=getnodes(node.right);
        int countnode=1+getleftnodes+getrightnodes;//左子树节点数+右子树节点数+中间节点
        return countnode;
    }
}

这里层序遍历也很适合解决

class Solution {
    public int countNodes(TreeNode root) {
        List<Integer> res=new ArrayList();
        ArrayDeque<TreeNode> queue=new ArrayDeque();
        if(root==null){
            return 0;
        }
        queue.addLast(root);
        while(!queue.isEmpty()){
            int size=queue.size();
            while(size>0){
                TreeNode node=queue.poll();
                res.add(node.val);
                if(node.left!=null){
                    queue.addLast(node.left);
                }
                if(node.right!=null){
                    queue.addLast(node.right);
                }
                size--;
            }
        }
        return res.size();

    }
}