代码随想录Day_16打卡

①、二叉树的最大深度

给定一个二叉树，找出其最大深度。

二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。

说明: 叶子节点是指没有子节点的节点。

事例：

给定二叉树 [3,9,20,null,null,15,7]，

    3
   / \
  9  20
    /  \
   15   7
返回它的最大深度 3 。

思路：

        迭代：使用层序遍历，在队列中的每次for循环就是每层个数的遍历，在for循环之前自增层数，最终得到的就是二叉树的最大深度。

public int maxDepth(TreeNode root){
        //迭代
        if(root == null) return 0;
        Deque<TreeNode> deque = new LinkedList<>();
        int res = 0;
        deque.offer(root);
        while(!deque.isEmpty()){
            int n = deque.size();
            res++;
            for(int i = 0;i < n;i++){
                TreeNode tmp = deque.poll();
                if(tmp.left != null) deque.offer(tmp.left);
                if(tmp.right != null) deque.offer(tmp.right);
            }
        }
        return res;
}

        递归：二叉树的最大深度就是左右子树的最大深度加1(当前层数)，故当做黑盒问题，依次递归求得左右子树，最后得到最大值 + 1，递归终止条件为 root == null。

代码：

public int maxDepth(TreeNode root){
        //递归
        if(root == null) return 0;
        int leftHigh = maxDepth(root.left);
        int rightHigh = maxDepth(root.right);

        return Math.max(leftHigh,rightHigh) + 1;
}

②、N叉树的最大深度

给定一个 N 叉树，找到其最大深度。

最大深度是指从根节点到最远叶子节点的最长路径上的节点总数。

N 叉树输入按层序遍历序列化表示，每组子节点由空值分隔（请参见示例）。

事例：

输入：root = [1,null,3,2,4,null,5,6]
输出：3

        做法跟二叉树差不多，就是递归或遍历左右子树变成递归或遍历集合。

代码：

public int maxDepth(Node root){
        //迭代
        if(root == null) return 0;
        Deque<Node> deque = new LinkedList<>();
        int res = 0;
        deque.offer(root);
        while(!deque.isEmpty()){
            int n = deque.size();
            res++;
            for(int i = 0;i < n;i++){
                Node tmp = deque.poll();
                List<Node> temp = tmp.children;
                for(Node node : temp){
                    deque.offer(node);
                }
            }
        }
        return res;
}

public int maxDepth(Node root){
        //递归
        if(root == null) return 0;
        List<Node> lists = root.children;
        int max = 0;
        for(Node node : lists){
            max = Math.max(maxDepth(node),max);
        }
        return max + 1;
}

③、二叉树的最小深度

给定一个二叉树，找出其最小深度。

最小深度是从根节点到最近叶子节点的最短路径上的节点数量。

说明：叶子节点是指没有子节点的节点。

事例：

输入：root = [3,9,20,null,null,15,7]
输出：2

思路：

        迭代：层序遍历每次for循环就是处理每层的结点，在遍历该层结点中，若遇到叶子结点，则就是该二叉树的最小深度。

代码：

public int minDepth(TreeNode root){
        //迭代
        if(root == null) return 0;
        Deque<TreeNode> deque = new LinkedList<>();
        int res = 0;
        deque.offer(root);
        while(!deque.isEmpty()){
            int n = deque.size();
            res++;
            for(int i = 0;i < n;i++){
                TreeNode tmp = deque.poll();
                if(tmp.left != null) deque.offer(tmp.left);
                if(tmp.right != null) deque.offer(tmp.right);
                if(tmp.left == null && tmp.right == null) return res;
            }
        }
        return res;
}

        递归：还是当做黑盒处理，但不是单纯的把max函数换成min函数，因为min函数并没有对空做反应，单叉树的最小深度取决于有孩子的一方，而min函数则直接返回无孩子的一方。递归做法最后得判断左右孩子的深度，若有一个为0，则返回另一个深度 + 1，若都有深度，则使用min函数返回小的 + 1。

代码：

public int minDepth(TreeNode root){
        //递归
        if(root == null) return 0;
        int leftMinHigh = minDepth(root.left);
        int rightMinHigh = minDepth(root.right);
        int min = 0;
        if(leftMinHigh * rightMinHigh == 0){
            min = leftMinHigh + rightMinHigh;
        }else{
            min = Math.min(leftMinHigh,rightMinHigh);
        }
        return min + 1;
}

④、完全二叉树的结点个数

给你一棵 完全二叉树 的根节点 root ，求出该树的节点个数。

完全二叉树 的定义如下：在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。若最底层为第 h 层，则该层包含 1~ 2h 个节点。

事例：

输入：root = [1,2,3,4,5,6]
输出：6

思路：

        这道题可以用递归遍历计数也可以使用层序遍历计数，但做法跟普通二叉树一致，也是处理了所有结点返回最终结果。

        针对这道题，有特殊做法。完全二叉树可以看做不同的满二叉树自底向上组成的，故使用递归遍历计数的时候，可以判断当前结点向下的子树是否为满二叉树，通过满二叉树的结点个数为2^(n) - 1，提前结束递归。

代码：

public int countNodes(TreeNode root) {
        if(root == null) return 0;
        TreeNode left = root.left;
        TreeNode right = root.right;
        int leftDepth = 0;
        int rightDepth = 0;
        while(left != null){
            leftDepth++;
            left = left.left;
        }
        while(right != null){
            rightDepth++;
            right = right.right;
        }
        if(leftDepth == rightDepth){
            return (2 << leftDepth) - 1;
        }

        int leftNum = countNodes(root.left);
        int rightNum = countNodes(root.right);
        return leftNum + rightNum + 1;
    }

参考：代码随想录 (programmercarl.com)