代码随想录算法训练营第十五天|104. 二叉树的最大深度、111. 二叉树的最小深度、222. 完全二叉树的节点个数-CSDN博客

104. 二叉树的最大深度

C++：队列

class Solution {
public:
    int maxDepth(TreeNode* root) {
      if(!root) return NULL;
      queue<TreeNode*> que;
      que.push(root);
      int ans=0;
      while(!que.empty()){
          int sz=que.size();
          for(int i=sz;i>0;i--){
              TreeNode*node=que.front();
              que.pop();
              if(node->left) que.push(node->left);
              if(node->right) que.push(node->right);
          }
          ans++;
      }
      return ans;
    }
};

C++：回溯+递归

class Solution {
public:
    int res;
    void Depth(TreeNode* root,int depth){
        res=res>depth?res:depth;
        if(root->left==nullptr&&root->right==nullptr) return;
        if(root->left) Depth(root->left,depth+1);
        if(root->right) Depth(root->right,depth+1);
        return;
    }

    int maxDepth(TreeNode* root) {
        res=0;
        if(root==nullptr) return res;
        Depth(root,1);
        return res;
    }
};

C++：

class solution {
public:
    int maxdepth(treenode* root) {
        if (root == null) return 0;
        return 1 + max(maxdepth(root->left), maxdepth(root->right));
    }
};

C#：队列

public class Solution {
    public int MaxDepth(TreeNode root) {
        if(root==null) return 0;
        Queue<TreeNode> que=new Queue<TreeNode>();
        bool flag=false;
        int res=0;
        que.Enqueue(root);
        while(que.Count!=0){
            int n=que.Count;
            for(int i=0;i<n;i++){
                TreeNode node =que.Dequeue();
                if(node.left!=null)
                    que.Enqueue(node.left);
                if(node.right!=null)
                    que.Enqueue(node.right);
                if(flag==true) 
                    res++;
            }
            res++;
        }
       return res;
    }
}

111. 二叉树的最小深度

C++:队列

需要注意判断在循坏里面

class Solution {
public:
    int minDepth(TreeNode* root) {
        int res=INT_MAX;int temp=0;
        if(root==nullptr) return NULL;
        queue<TreeNode*> que;
        que.push(root);
        while(!que.empty()){
            int n=que.size();

            temp++;
            for(int i=0;i<n;i++){
                 TreeNode* node=que.front();
                que.pop();
                if(node->left) que.push(node->left);
                //else que.push(nullptr);
                if(node->right) que.push(node->right);
                //else que.push(nullptr);
                if(node->left==nullptr&&node->right==nullptr){
                res=res<temp?res:temp;
                }
            }
        }
        return res;
    }
};

C++:回溯+递归

class Solution {
public:
    int res=INT_MAX;
    void Depth(TreeNode* root,int depth){
        if(root==nullptr) return;
        if(root->left==nullptr&&root->right==nullptr){
            res=res<depth?res:depth;
        }

        if(root->left!=nullptr) Depth(root->left,1+depth);     
        if(root->right!=nullptr) Depth(root->right,1+depth);

        return;
    }

    int minDepth(TreeNode* root) {
        if(root==nullptr) return 0;
        Depth(root,1);
        return res;
    }
};

C#:队列

class Solution {
public:
    int minDepth(TreeNode* root) {
        int res=INT_MAX;int temp=0;
        if(root==nullptr) return NULL;
        queue<TreeNode*> que;
        que.push(root);
        while(!que.empty()){
            int n=que.size();

            temp++;
            for(int i=0;i<n;i++){
                 TreeNode* node=que.front();
                que.pop();
                if(node->left) que.push(node->left);
                //else que.push(nullptr);
                if(node->right) que.push(node->right);
                //else que.push(nullptr);
                if(node->left==nullptr&&node->right==nullptr){
                res=res<temp?res:temp;
                }
            }
            
        }
        return res;
    }
};

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

C++:

class Solution {
public:
    int countNodes(TreeNode* root) {
        
        if(root==nullptr) return 0;
        queue<TreeNode*> que;
        que.push(root);
        int res=0;
        while(!que.empty()){
            //int n=que.size();
            TreeNode* node=que.front();
                que.pop();
            res++;
            
                
                if(node->left!=nullptr) que.push(node->left);
                if(node->right!=nullptr) que.push(node->right);
            
        }
        return res;
    }
};

C++:迭代

class Solution {
public:
    int countNodes(TreeNode* root) {
        if(root==nullptr) return 0;
        return 1+countNodes(root->left)+countNodes(root->right);        
    }
};

C#:

public class Solution {
    public int CountNodes(TreeNode root) {
        if(root==null) return 0;
        int res=0;
        Queue<TreeNode> que=new Queue<TreeNode>();
        que.Enqueue(root);
        while(que.Count!=0){
            TreeNode node=que.Dequeue();
            res++;
            if(node.left!=null) que.Enqueue(node.left);
            if(node.right!=null) que.Enqueue(node.right);
        }
        return res;
    }
}