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

Day16

104 二叉树的最大深度

递归法

后序遍历，（求的是某节点到该节点的所有叶子节点的最长的长度）

因为是从底部往上遍历。

先求左子树长度，再求右子树长度，最后求该树的最大值。

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) {
        if(root==NULL) return 0;
        int depth=getDepth(root);
        return depth;
    }
};

前序遍历，（求的是根节点到该节点的最长的长度。）

从根节点开始往下一层层找（主要是回溯）

class Solution {
public:
    int result;
    int getDepth(TreeNode* node,int depth){
        result= result>depth?result:depth;
        if(node->left){
            depth++;
            getDepth(node->left,depth);
            depth--;
        }
        if(node->right){
            depth++;
            getDepth(node->right,depth);
            depth--;
        }
        return depth;
    }
    int maxDepth(TreeNode* root) {
        if(root==NULL) return 0;
        int depth=1;
        getDepth(root,1);
        return result;
    }
};

559 n叉树的最大深度

这个有点难，自己思考了下，按照后序，从下往上，比较所有子树的长度，取最大，然后+1返回上一级。首先要初始化depth，然后保存最大深度。

class Solution {
public:
    int getDepth(Node* node){
        if(node==NULL) return 0;
        int depth=0;
        for(int i=0;i<node->children.size();i++){
            depth=max(depth,getDepth(node->children[i]));
        }
        return depth+1;
    }
    int maxDepth(Node* root) {
        if(root==NULL) return 0;
        int depth=0;
        depth=getDepth(root);
        return depth;
    }
};

111.二叉树的最小深度

使用递归的时候要分析出所有的情况，比如左子树没有，右子树没有等等，然后写出来，我感觉前序和后序更像是处理数据在前，还是递归在前，

就像这个，递归肯定是找到叶节点才可以停止，如果有左孩子或者右孩子，就要像那个方向发展，而不是像最大深度那样，直接用max函数就可以。

前序写法：

class Solution {
public:
    int result;
    void getDepth(TreeNode* root,int depth){
        if(root==NULL) return;
        if(root->left==NULL &&root->right==NULL){
            result=min(result,depth);
        }
        if(root->left){
            getDepth(root->left,depth+1);
        }
        if(root->right){
            getDepth(root->right,depth+1);
        }
        return ;
    }
    int minDepth(TreeNode* root) {
        if(root==NULL) return 0;
        result=INT_MAX;
        getDepth(root,1);
        return result;
    }
};

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

利用完全二叉树的性质的递归：

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

普通二叉树的递归：

跟遍历二叉树思路差不多：

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