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

104.二叉树的最大深度

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

最大深度其实就是根节点的高度。前序遍历求得是深度，后序遍历求的是根节点的高度，两种方法都可以得出二叉树的最大深度。

后续遍历（递归）：

class Solution {
public:
    int getDepth(TreeNode* node){
        if(node==nullptr) 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 res;
    void getDepth(TreeNode* node,int depth){
        res=max(res,depth);
        if(node->left==nullptr&&node->right==nullptr) return;
        if(node->left){
            depth++;
            getDepth(node->left,depth);
            depth--;
        }
         if(node->right){
            depth++;
            getDepth(node->right,depth);
            depth--;
        }
        return;
    }
    int maxDepth(TreeNode* root) {
        if(root==nullptr) return res;
        getDepth(root,1);
        return res;
    }
};

也可以用层序遍历求最大深度，定义一个变量层数，每遍历一层层数加一即可：

class Solution {
public:
    int maxDepth(TreeNode* root) {
        queue<TreeNode*> que;
        if(root) que.push(root);
        int depth=0;
        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;
    }
};

111.二叉树的最小深度

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

注意本题目最小深度要求是叶子节点到根节点的距离，如果根节点只有只有左子树或只有右子树，那么缺失的子树不是最小深度，因为没有叶子节点。如图

class Solution {
public:
    int getDepth(TreeNode* node){
        if(node==nullptr) return 0;         //根节点为空深度为0
        int leftdepth=getDepth(node->left);
        int rightdepth=getDepth(node->right);       //分别获取左右子树的深度
        if(!node->left&&node->right) return rightdepth+1;   //左子树空右子树不空，深度为右子树深度+1（因为从0开始计数
        if(node->left&&!node->right) return leftdepth+1;   //右子树空右子树不空，深度为左子树深度+1
        int result=min(leftdepth,rightdepth)+1;  //取左右子树深度小的那一个为最小深度
        return result;
    }
    int minDepth(TreeNode* root) {
        return getDepth(root);
    }
};

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

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

如果忽略二叉树的特殊性质，把他当作普通的树看待，那么在遍历的时候，设置一个计数器，每遍历一个节点，计数器加一即可。

递归法：

class Solution {
private:
    int getNodesNum(TreeNode* cur) {
        if (cur == NULL) return 0;
        int leftNum = getNodesNum(cur->left);      // 左
        int rightNum = getNodesNum(cur->right);    // 右
        int treeNum = leftNum + rightNum + 1;      // 中
        return treeNum;
    }
public:
    int countNodes(TreeNode* root) {
        return getNodesNum(root);
    }
};

因为实在首先是一颗完全二叉树，那么如果它的子树的左右外侧深度相等，这棵子树就一定是满二叉树。

根据满二叉树节点数量（2^n-1，n为根节点的高度）的性质，可以直接计算出节点个数。

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