day-16 代码随想录算法训练营（19）二叉树part03 已二刷

104.二叉树的最大深度

思路一：层序遍历

见day-15

思路二：递归遍历

class Solution {
public:
    int result;
    void judge(TreeNode*root,int deepth)
    {
        result=max(deepth,result);
        if(root->left==nullptr && root->right==nullptr)
            return;
        if(root->left)
            judge(root->left,deepth+1);
        if(root->right)
            judge(root->right,deepth+1);
    }
    int maxDepth(TreeNode* root) {
        if(root==nullptr)
            return 0;
        result=0;
        judge(root,1);
        return result;
    }
};

分析：重点在于全局变量的更新，以及deepth变量作为值传递，每一层的改变并不会影响其他层数据的改变

二刷路过

111.二叉树的最小深度

思路一：跟最大深度差不多，主要就是在叶子节点处更新最小值的变化

class Solution {
public:
    int res;
    void judge(TreeNode*root,int mindeepth)
    {
        if(root->left==nullptr && root->right==nullptr)
            res=min(res,mindeepth);
        if(root->left)
            judge(root->left,mindeepth+1);
        if(root->right)
            judge(root->right,mindeepth+1);
    }
    int minDepth(TreeNode* root) {
        if(root==nullptr)
            return 0;
        res=INT_MAX;
        judge(root,1);
        return res;
    }
};

 二刷路过：

class Solution {
public:
    int res=INT_MAX;
    void judge(TreeNode*root,int deep){
        if(root->left==nullptr && root->right==nullptr){//根节点判断深度
            if(deep<res) res=deep;//更新最小深度
            return;
        }
        if(root->left) judge(root->left,deep+1);
        if(root->right) judge(root->right,deep+1);
    }
    int minDepth(TreeNode* root) {
        if(root==nullptr) return 0;
        judge(root,1);
        return res;
    }
};

 

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

思路一：直接递归遍历（前序），当前节点记录节点数量

class Solution {
public:
    void judge(TreeNode*root,int &nums)
    {
        if(root==nullptr)
            return;
        nums++;
        judge(root->left,nums);
        judge(root->right,nums);
    }
    int countNodes(TreeNode* root) {
        //思路：递归遍历
        if(root==nullptr)
            return 0;
        int nums=0;
        judge(root,nums);
        return nums;
    }
};

思路二：层序遍历，在每一层节点数量nums+=que.size()

 

二刷路过：

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

 

110.平衡二叉树

分析：这一题判断的是每个节点的左右子树的高度差是否小于等于1

思路：后序递归

class Solution {
public:
    int judge(TreeNode*root)
    {
        if(root==nullptr)
            return 0;
        int deepl=judge(root->left);
        if(deepl==-1)  return -1;
        int deepr=judge(root->right);
        if(deepr==-1)  return -1;

        int res=0;
        if(abs(deepl-deepr)>1) return -1;
        else{
            res=1+max(deepl,deepr);
        }
        return res;
    }
    bool isBalanced(TreeNode* root) {
        //思路：递归遍历计算每一个叶子节点的深度，判断是否和其他叶子节点的最大深读相差1
        //思路二：递归遍历每一个节点的左右子树深度，判断是否差值小于等于1
        if(root==nullptr)
            return true;
        return judge(root)==-1?false:true;
    }
};

分析：求二叉树的深度和高度需要明确遍历的顺序，高度必然是后序，因为需要先判断左右子树的高度

二刷路过：后序遍历，判断左右子树的高度

class Solution {
public:
    int judge(TreeNode*root){
        int ldeep=0,rdeep=0;
        if(root->left) ldeep=judge(root->left);//左子树高度
        if(ldeep==-1) return -1;

        if(root->right) rdeep=judge(root->right);//右子树高度
        if(rdeep==-1) return -1;

        if(ldeep-rdeep>1 || rdeep-ldeep>1) return -1;//左右子树高度差
        return ldeep>rdeep?ldeep+1:rdeep+1;
    }
    bool isBalanced(TreeNode* root) {
        if(root==nullptr) return true;//结点数为0
        if(judge(root)==-1) return false;//遍历结果
        return true;
        
    }
};