代码随想录训练营第十六天|104.二叉树的最大深度 559.n叉树的最大深度● 111.二叉树的最小深度● 222.完全二叉树的节点个数

104.二叉树的最大深度

import java.util.ArrayDeque;
import java.util.Deque;

public class day16_104_二叉数的最大深度 {
    public static class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;

        TreeNode() {
        }

        TreeNode(int val) {
            this.val = val;
        }

        TreeNode(int val, TreeNode left, TreeNode right) {
            this.val = val;
            this.left = left;
            this.right = right;
        }
    }
    public static void main(String[] args) {
        
    }
    
    public static int diguiti(TreeNode demo){
        if (demo==null) {
            return 0;
            
        }
        int leftdep=diguiti(demo.left);
        int rightdep=diguiti(demo.right);
        int myhigh=Math.max(leftdep, rightdep)+1;
        //根节点的高度就是左右节点的最高高度然后再加上一就对了
        return myhigh;

    }
    //层序遍历比较简单，便于理解
    //尝试写递归的算法
    public static int maxdep(TreeNode root){
        int high=0;
        Deque<TreeNode> temp=new ArrayDeque<>();
        //这个是存放节点的
        if (root==null) {
            return high;
            
        }
        
        temp.offer(root);
        //
        while (!temp.isEmpty()) {
            int len=temp.size();//
            for(int i=0;i<len;i++){
                TreeNode demo=temp.pollFirst();
                if (demo.left!=null) {
                    temp.offer(demo.left);
                    
                }
                if (demo.right!=null) {
                    temp.offer(demo.right);
                    
                }
                len-=1;
                



            }
            high+=1;
            
        }
            
        
        //这里是判断如果不为空就加入
        return high;

    }

    
}

这就是两种写法，第一种就是常规的层序遍历，把一层遍历结束就加一，这是最容易理解的一种

第二种就是用递归，整体递归体的思路就是，先左右，然后是gen，跟的高度就是左右的最大值然后再加上一，这样就的到了。

n叉树的高度

import java.util.ArrayDeque;
import java.util.Deque;
import java.util.LinkedList;
import java.util.List;

public class day16_559_n叉树的最大高度 {
    public static class TreeNode {
        public int val;
        public List<TreeNode> children;

        public TreeNode() {}

        public TreeNode(int _val) {
            val = _val;
        }

        public TreeNode(int _val, List<TreeNode> _children) {
            val = _val;
            children = _children;
    }
    public static void main(String[] args) {
        

    }
    //首先尝试一下层序的n叉树的
    public static int nmaxdeep(TreeNode root){
        int high=0;
        if (root==null) {
            return 0;
            
        }
        Deque<TreeNode> temp=new LinkedList<>();
        temp.offer(root);
        while (!temp.isEmpty()) {
            int len=temp.size();
            high+=1;
            for(int i=0;i<len;i++){
                TreeNode demo=temp.pollFirst();
                int chisize=demo.children.size();
                for(int j=0;j<chisize;j++){
                    if (demo.children.get(j)!=null) {
                        temp.offer(demo.children.get(j));
                        
                    }
                    
                    
                }
                
                
                
            }
            
            
            
        }
        return high;
        
    }

    
}
}

思路是一样的，就是入队的时候不是左右子树而是遍历子节点的列表

。

最小深度

import java.util.Deque;
import java.util.LinkedList;

public class day16_111_二叉树的最小深度 {
    public class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;
        TreeNode() {}
        TreeNode(int val) { this.val = val; }
        TreeNode(int val, TreeNode left, TreeNode right) {
           this.val = val;
           this.left = left;
           this.right = right;
        }
       }
    public static void main(String[] args) {
        
    }
    public int minDepth(TreeNode root){
        //这就是找最小深度，也就是遇到的第一叶子结点，叶子结点就是左右节点都是空的
        Deque<TreeNode> temp=new LinkedList<>();
        int high=0;
        if (root==null) {
            return 0;
            
        }
        temp.offer(root);
        while (!temp.isEmpty()) {
            high+=1;
            int len=temp.size();
            for(int i=0;i<len;i++){
                TreeNode demo=temp.pollFirst();
                //第一个弹出
                if (demo.left==null&&demo.right==null) {
                    return high;
                    
                }
                if (demo.left!=null) {
                    temp.offer(demo.left);
                    
                }
                if (demo.right!=null) {
                    temp.offer(demo.right);
                    
                }
            }



            
        }
        return high;
    }
    
}

记住这个层序遍历的方法就行，遇到的第一个叶子节点，也就是没有左右字数的节点。

求完全二叉树的节点

public class day16_222_完全二叉数节点的数量 {
    public class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;
        TreeNode() {}
        TreeNode(int val) { this.val = val; }
        TreeNode(int val, TreeNode left, TreeNode right) {
           this.val = val;
           this.left = left;
           this.right = right;
        }
       }
    public static void main(String[] args) {
        
    }
    public int countnode(TreeNode root){
        if (root==null) {
            return 0;
            
        }
        int leftcount=countnode(root.left);
        int rightcount=countnode(root.right);
        int sum=leftcount+rightcount+1;
        return sum;
    }


    
}

会写层序和递归就行了，利用特性没必要