【day16】二叉树的最大最小深度，完全二叉树的节点个数

1.二叉树的最大深度

给定一个二叉树，找出其最大深度。二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。
说明: 叶子节点是指没有子节点的节点。
示例：
给定二叉树 [3,9,20,null,null,15,7]，返回最大深度3。

1.后序遍历法，返回左右子树深度值较大者，根节点+1；

/**
 * Definition for a binary tree node.
 * function TreeNode(val, left, right) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.left = (left===undefined ? null : left)
 *     this.right = (right===undefined ? null : right)
 * }
 */
/**
 * @param {TreeNode} root
 * @return {number}
 */
var maxDepth = function(root) {
    return depth(root);
};

var depth = function(root){
    if(root == null){
        return 0;
    }
    let leftdepth = depth(root.left);
    let rightdepth = depth(root.right);
    let count = 1 + Math.max(leftdepth,rightdepth);
    return count;
}

2.层序遍历

var maxDepth = function(root) {
    if(root == null){
        return 0;
    }
    let queue = [];
    let result = 0;
    queue.push(root);
    while(queue.length > 0){
        let size = queue.length;
        while(size--){
            let node = queue.shift();
            if(node.left !== null){
                queue.push(node.left);
            }
            if(node.right !== null){
                queue.push(node.right);
            }
        }
        result ++;
    }
    return result;
};

2.二叉树的最小深度

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

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

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

示例:

给定二叉树 [2,null,3,null,4,null,5,null,6]，最小深度为5

注意：当左 右子树其中一个为null，一个不能null时，要取不为空的节点，如上图所示的二叉树，最大最小深度都为5，只存在一个叶子节点；

var minDepth = function(root) {
    return depth(root);
};

var depth = function(root){
    if(root == null){
        return 0;
    }
 
   let left = depth(root.left)
   let right = depth(root.right);
   if(root.left == null && root.right != null){
       return 1+right;
   }
   if(root.right == null && root.left != null){
       return 1+left;
   }
    return 1+Math.min(left,right);
}

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

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

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

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

1.常规写法：后序递归遍历，所有节点都遍历一遍，

/**
 * Definition for a binary tree node.
 * function TreeNode(val, left, right) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.left = (left===undefined ? null : left)
 *     this.right = (right===undefined ? null : right)
 * }
 */
/**
 * @param {TreeNode} root
 * @return {number}
 */
var countNodes = function(root) {
    return count(root);
};
var count = function(root){
    if(root == null){
        return 0;
    }
    let leftcount = count(root.left);
    let rightcount = count(root.right);
    return 1+leftcount+rightcount;
}

2.利用满二叉树节点数公式：深度为k，有2^(k-1)次方个节点，增加递归结束条件判断，如果判断子树为满二叉树直接利用公式计算出子树的节点个数，左右子树节点个数相加，再加上根节点+1，得到完全二叉树的节点数;
因为该二叉树为完全二叉树，叶子节点中间不能中断的特性，所以判断左右子树是否为满二叉树可以直接根据左子树一直往左的深度是否等于右子树一直往右的深度是否相等，不相等则不是满二叉树；

var countNodes = function(root) {
    return count(root);
};

var count = function(root){
    if(root == null){
        return 0;
    }
    let nodeleft = root.left;
    let noderight = root.right;
    let depthleft = 1;
    let depthright = 1;
    while(nodeleft != null){
        nodeleft = nodeleft.left;
        depthleft++;
    }
    while(noderight != null){
        noderight = noderight.right;
        depthright++;
    }
    if(depthleft == depthright){
        
        return Math.pow(2,depthleft) - 1;
    }

    let countleft = count(root.left);
    let countright = count(root.right);
    return countleft + countright + 1;
}