代码随想录算法训练营第十六天| LC104. 二叉树的最大深度、LC111. 二叉树的最小深度、LC222. 完全二叉树的节点个数

LeetCode 104 二叉树的最大深度

题目链接：104. 二叉树的最大深度

做题情况：自己在独立做题目时候严格按照写递归算法的三部曲，然后ac出来了，但是自己并不知道深度和高度的区别，后序遍历以及前序遍历啥的，相当于懵懵懂懂地ac出来了，看完卡哥视频和代码随想录书相关部分后，重点掌握了什么是深度？什么是高度？以及两种情况采用何种遍历方式？以及咋样来合并两种情况来写出代码，当时自己ac的代码如下：

/**
 * 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 maxDepth(TreeNode* root) {
        if(root==NULL)return 0;
        int leftMaxDept=maxDepth(root->left);
        int rightMaxDept=maxDepth(root->right);
        int ans =max(leftMaxDept, rightMaxDept)+1;
        return ans;
    }
};

还可以写出更精简的代码，只要取消一些变量的声明即可，不过不好理解，本题也可以直接采用前序遍历来进行求最大深度，代码如下（自己边抄卡哥代码边学习）：

/**
 * 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 result;
    void getdepth(TreeNode* node, int depth){
        result=depth>result?depth:result;//中
        if(node->left==NULL&&node->right==NULL)return;
        if(node->left){//左
            getdepth(node->left, depth+1);
        }
        if(node->right){//右
            getdepth(node->right, depth+1);
        }
        return;
    }

    int maxDepth(TreeNode* root) {
        result=0;
        if(root==NULL)return result;
        getdepth(root, 1);
        return result;
    }
};

本题目也可以采用迭代法，即层序遍历，只要知道最大深度和层数相等即可，采用层序遍历统一模板来写代码顺便进行记录层数，代码如下：

/**
 * 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 maxDepth(TreeNode* root) {
        int res=0;
        queue<TreeNode*>que;
        if(root==NULL)return 0;
        que.push(root);
        while(!que.empty()){
            int size=que.size();
            while(size--){
                if(que.front()->left)que.push(que.front()->left);
                if(que.front()->right)que.push(que.front()->right);
                que.pop();    
            }
            res++;
        }
        return res;
    }
};

LeetCode 111 二叉树的最小深度

题目链接：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* node){
        if(node==NULL)return 0;
        int leftDepth=getDepth(node->left);
        int rightDepth=getDepth(node->right);

        if(node->left==NULL&&node->right!=NULL){
            return 1+rightDepth;
        }

        if(node->left!=NULL&&node->right==NULL){
            return 1+leftDepth;
        }
        int result=1+min(leftDepth, rightDepth);
        return result;
    }

    int minDepth(TreeNode* root) {
        return getDepth(root);
    }
};

本题目也可以采用和上述一样的前序遍历和层序遍历（迭代法）来进行解答，具体可以参考卡哥所给代码。

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

题目链接：222. 完全二叉树的节点个数

做题情况：本题自己采用普通二叉树遍历的方式ac出来了，时间复杂度为O(n)，但是想利用完全二叉树的性质来解答此题目，自己没有想出来，具体ac代码如下：

/**
 * 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 res=0;
    int countNodes(TreeNode* root) {
        if(root==NULL)return 0;
        res++;
        countNodes(root->left);
        countNodes(root->right);
        return res;
    }
};

看完卡哥视频和代码随想录书相关部分后，利用完全二叉树的性质才知道是在终止条件时候多加上一个条件来判断满二叉树从而利用公式进行出节点数以免全部遍历，从而达到以免全部遍历n个节点的目的，具体代码如下：

/**
 * 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 countNodes(TreeNode* root) {
        if(root==NULL)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;
    }
};

此处在完全二叉树中判断子树是否是满二叉树的方法值得好好学习

今天自己独立ac出第一道和第三道题目，发现自己现在写二叉树递归算法越来越有感觉了，牢记递归三部曲，继续加油，总共花了四个半小时左右。

贵在坚持，加油，共勉