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

104.二叉树的最大深度

/**
 * @param {TreeNode} root
 * @return {number}
 */
 /****递归思想***************************************************/
     var deep=function(root){
        if(root.left===0&&root.right===0)
            return 1
        let l=0,r=0
        if(root.left)  l=deep(root.left)
        if(root.right) r=deep(root.right)
        return 1 + Math.max(l,r)
    }

    var maxDepth = function(root) {
        return deep(root)
    };
/****层序遍历****************************************************/
    var maxDepth = function(root) {
        let i=0
        if(root===null) return 0
        let queue=[root] //队列
        while(queue.length!==0){//当queue里没有数时
            let size=queue.length
            while(size!==0){ //把此层弹出，并把他们的儿子多少个，并入队
        	    let x = queue.shift() //弹出头部
                if(x.left)    queue.push(x.left)    //下一层计数            
                if(x.right)   queue.push(x.right) 
                size--
        }
        i++
    }
    return i
    };

第一想法

递归，但还是写不出来，我的递归什么时候可以好

收获

• 法一let r定义时要赋值

---

111. 二叉树的最小深度

/**
 * 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 deep=function(root){
        if(root.left===null&&root.right===null)
            return 1
        let l=0,r=0
        if(root.left)  l=deep(root.left)
        if(root.right) r=deep(root.right)
        if(l===0||r===0) return r+l+1
        else
         return  1+Math.min(l,r)
    }
	var minDepth = function(root) {
    	if(!root) return 0
   	    return deep(root)
};

思路

和max差不多，max遇到最底部一个节点，返回。
min是遇到第一个叶子节点就可以返回来了
采用后序遍历，先访问左右节点，返回最小值。

例一：

过程：
3左边节点9返回1.
15 7返回1,20（3的右边）返回2.
所以3返回3

---

例二：

如果没有着一句

if(l===0||r===0) return r+l+1

他每一次都会返回1（和0取小+1）
只有在两边都有返回时才取min

困难

• 题意

最近的叶子节点深度（4是最小深度，5,6是最大深度）

层序遍历

/**
 * 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 minDepth = function(root) {
        let i=0
        if(root===null) return 0
        let queue=[root] //队列
        while(queue.length!==0){//当queue里没有数时
            let size=queue.length
            while(size!==0){ //把此层弹出，并把他们的儿子多少个，并入队
        	    let x = queue.shift() //弹出头部
                if(!x.left&&!x.right) return i+1
                else{
                     if(x.left)    queue.push(x.left)    //下一层计数            
                     if(x.right)   queue.push(x.right) 
                	 size--
                    }
                }
                i++
        }
};

思路

return条件，遇到左右孩子都没的，就走。
因为我的一层一层遍历的，下图两种情况都可以识别。只需 i++放在大的while里面记录层数

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

/**
 * 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 count=function(root){
        if(root.left===null&&root.right===null)
            return 1
        let l=0,r=0
        if(root.left)  l=count(root.left)
        if(root.right) r=count(root.right)
        return  l+r+1
    }
var countNodes = function(root) {
    if(!root) return 0
    return count(root)
};
/**层序遍历***/

var countNodes = function(root) {
   let res = []
    if(root===null) return res
    let queue=[root] //队列
    while(queue.length!==0){//当queue里没有数时
        let size=queue.length
        while(size!==0){ //把此层弹出，并把他们的儿子多少个，并入队
        	let x = queue.shift() //弹出头部
        	res.push(x.val)  //此层弹入
            if(x.left)    queue.push(x.left)    //下一层计数            
            if(x.right)   queue.push(x.right) 
            size--
        }
    }
    return res.length
  };,
    /******根据完全二叉树特性做法*******************************/
    

var countNodes = function(root) {
  //利用完全二叉树的特点
    if(root===null){
        return 0;
    }
    let left=root.left;
    let right=root.right;
    let leftDepth=0,rightDepth=0;
    while(left){
        left=left.left;
        leftDepth++;
    }
    while(right){
        right=right.right;
        rightDepth++;
    }
    if(leftDepth==rightDepth){
        return Math.pow(2,leftDepth+1)-1;
    }
    return countNodes(root.left)+countNodes(root.right)+1;
};

第一想法

递归（后序遍历）+层序+迭代（前中后都可，放入数组,求nums.length）都可以做出来。
但都是普通二叉树的求节点数方法

思想

完全二叉树思想：

• 前提：2^树深度 - 1 来计算，注意这里根节点深度为1。
• 分别递归左孩子，和右孩子，如果左孩子右孩子深度一样，就是满二叉树,直接用公式算。
• 如果不一样递归到最后就剩一个单节点（根节点）， Math.pow(2,leftDepth+1)-1;,leftDepth==0,返回1。递归结束
  
  

补充题：
559.n叉树的最大深度

/**
 * // Definition for a Node.
 * function Node(val,children) {
 *    this.val = val;
 *    this.children = children;
 * };
 */

/**
 * @param {Node|null} root
 * @return {number}
 */

    var maxDepth = function(root) {
    if (!root) {
        return 0;
    }
    let maxChildDepth = 0;
    const children = root.children;
    for (const child of children) {
        const childDepth = maxDepth(child);
        maxChildDepth = Math.max(maxChildDepth, childDepth);
    }
    return maxChildDepth + 1;
};

const children = root.children;把孩子当成数组