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

104.二叉树的最大深度

跟节点的高度就是二叉树的深度，所以可以通过后序/前序求跟节点的高度来求深度

递归法代码：

/**
 * 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);
        int depth=1+max(leftdepth,rightdepth);
        return depth;

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

    }
};

 迭代法：

使用层序遍历最合适，相当于记录有几层

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

559.n叉树的最大深度 

思路跟上个题一样

递归法

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;
    }
};

迭代法

class solution {
public:
    int maxDepth(Node* root) {
        queue<Node*> que;
        if (root != NULL) que.push(root);
        int depth = 0;
        while (!que.empty()) {
            int size = que.size();
            depth++; // 记录深度
            for (int i = 0; i < size; i++) {
                Node* node = que.front();
                que.pop();
                for (int j = 0; j < node->children.size(); j++) {
                    if (node->children[j]) que.push(node->children[j]);
                }
            }
        }
        return depth;
    }
};

 111.二叉树的最小深度

前序求的是深度，后序求的是高度。最小深度是从根节点到最近叶子节点的最短路径上的节点数量

 代码如下

/**
 * 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 rigthdepth=getdepth(root->right);
        if(root->left==NULL&&root->right!=NULL)
            return 1+rigthdepth;
        if(root->left!=NULL&&root->right==NULL)
            return 1+leftdepth;
        int result=1+min(leftdepth,rigthdepth);
        return result;
        
    }
    int minDepth(TreeNode* root) {
        return getdepth(root);

    }
};

迭代法

需要注意的是，只有当左右孩子都为空的时候，才说明遍历到最低点了。如果其中一个孩子不为空则不是最低点

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

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

普通二叉树

迭代法

代码如下

class Solution {
public:
    int countNodes(TreeNode* root) {
        queue<TreeNode*> que;
        if (root != NULL) que.push(root);
        int result = 0;
        while (!que.empty()) {
            int size = que.size();
            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();
                result++;   // 记录节点数量
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
        }
        return result;
    }
};