代码随想录训练营day16|104.二叉树的最大深度，111.二叉树的最小深度222.完全二叉树的节点个数

er

104. 二叉树的最大深度 - 力扣（LeetCode）

/**
 * 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* root)
    {
        if(root==NULL)
        return 0;
        int leftdepth=getdepth(root->left);
        int rightdepth=getdepth(root->right);
        int depth=max(leftdepth,rightdepth)+1;
        return depth;
    }
    int maxDepth(TreeNode* root) {
       return getdepth(root);
    }
};

 二叉树的高度是指每层结点到叶子结点的距离（从下往上，后序遍历），而二叉树的深度（前序遍历）是每个节点到根节点的距离，根节点的高度其实就是二叉树的最大深度

111. 二叉树的最小深度 - 力扣（LeetCode）

看起来好像做过，一写就错！ | LeetCode：111.二叉树的最小深度_哔哩哔哩_bilibili

/**
 * 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 getmindepth(TreeNode* root)
    {
        if(root==NULL)
        return 0;
        int leftdepth=getmindepth(root->left);
        int rightdepth=getmindepth(root->right);
        if(root->left==NULL&&root->right!=NULL)
        return rightdepth+1;
        if(root->right==NULL&&root->left!=NULL)
        return leftdepth+1;
        int result=1+min(leftdepth,rightdepth);//注意这里不是所有的是时候都是两者取最小值，当左子树为空时是取右子树的高度。最小深度是最靠近根节点的叶子节点的高度
            return result;
        
    }
    int minDepth(TreeNode* root) {
        return getmindepth(root);
       }
};

222. 完全二叉树的节点个数 - 力扣（LeetCode）

第一眼思路：利用层序遍历统计节点的个数；

/**
 * 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 countNodes(TreeNode* root) {
      queue<TreeNode*> que;
      if(root!=NULL)
      que.push(root);
      int sum=0;
      while(!que.empty())
      {
          int size=que.size();
          sum+=size;
          TreeNode* node;
          while(size--)
          {
              node=que.front();
              que.pop();
              if(node->left)
              que.push(node->left);
              if(node->right)
              que.push(node->right);
          }
      }
      return sum;
    }
};

/**
 * 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 sum1(TreeNode* root)
    {
        if(root==NULL)
        return 0;
        int leftsum=sum1(root->left);
        int rightsum=sum1(root->right);
        int result=1+leftsum+rightsum;
        return result;
    }
    int countNodes(TreeNode* root) {
        return sum1(root);
    }
};