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

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

迭代法，大家可以直接过，二刷有精力的时候 再去掌握迭代法。

详细布置

104.二叉树的最大深度 （优先掌握递归）

什么是深度，什么是高度，如何求深度，如何求高度，这里有关系到二叉树的遍历方式。

大家 要先看视频讲解，就知道以上我说的内容了，很多录友刷过这道题，但理解的还不够。

题目链接/文章讲解/视频讲解：
https://programmercarl.com/0104.%E4%BA%8C%E5%8F%89%E6%A0%91%E7%9A%84%E6%9C%80%E5%A4%A7%E6%B7%B1%E5%BA%A6.html

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int depth(TreeNode* node)//后序遍历
    {
        if(node==NULL)
        return 0;

        int leftdepth=depth(node->left);
        int rightdepth=depth(node->right);
        int depthlength=1+max(leftdepth,rightdepth);
        return depthlength;

    }
    int maxDepth(TreeNode* root) {
            return depth(root);
    }
};

559. N 叉树的最大深度

/*
// Definition for a Node.
class Node {
public:
    int val;
    vector<Node*> children;

    Node() {}

    Node(int _val) {
        val = _val;
    }

    Node(int _val, vector<Node*> _children) {
        val = _val;
        children = _children;
    }
};
*/

class Solution {//扩展可以磨磨脑子
public:
    int maxDepth(Node* root) {
        if(root==0)return 0;
        int depth=0;
        for(int i=0;i<root->children.size();i++)
        {
            depth=max(depth,maxDepth(root->children[i]));
        }
        return depth+1;
    }
};```

 **111.二叉树的最小深度 （优先掌握递归）**

先看视频讲解，和最大深度 看似差不多，其实 差距还挺大，有坑。

> 题目链接/文章讲解/视频讲解：https://programmercarl.com/0111.%E4%BA%8C%E5%8F%89%E6%A0%91%E7%9A%84%E6%9C%80%E5%B0%8F%E6%B7%B1%E5%BA%A6.html

```cpp
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int getdepth(TreeNode* node)
    {
        if(node==NULL)
        return 0;
        int leftdepth=getdepth(node->left);//左
        int rightdepth=getdepth(node->right);//右
//中

 // 当一个左子树为空，右不为空，这时并不是最低点
        if(node->left==NULL&&node->right!=NULL)
        {
                return  rightdepth+1;
        }
// 当一个右子树为空，左不为空，这时并不是最低点
        if(node->left!=NULL&&node->right==NULL)
        {
                return leftdepth+1;
        }
            int result=min(leftdepth,rightdepth)+1;//每次遍历到一个结点就+1
            return result;

    }

    int minDepth(TreeNode* root) {
       return getdepth(root);

    }
};

222.完全二叉树的节点个数（优先掌握递归）

需要了解，普通二叉树 怎么求，完全二叉树又怎么求

题目链接/文章讲解/视频讲解：https://programmercarl.com/0222.%E5%AE%8C%E5%85%A8%E4%BA%8C%E5%8F%89%E6%A0%91%E7%9A%84%E8%8A%82%E7%82%B9%E4%B8%AA%E6%95%B0.html

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int bianli(TreeNode* node)
    {
        if(node==NULL)
        return 0;
        int leftnum=bianli(node->left);
        int rightnum=bianli(node->right);
        int result=leftnum+rightnum+1;
        return result;
    }
    int countNodes(TreeNode* root) {
        return bianli(root);
    }
};