代码随想录算法训练营第十六天

懈怠的一天，没有补十七天，先把十六天写完。

104.二叉树的最大深度 （优先掌握递归）

递归法：

自己没做出来，有点过于巧妙，深度为1+左右子树的最大值

/**
 * 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 == 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);
    }
};

回溯这个方法很牛，第一行很重要，这个决定result永远是最大的那个。

result = depth > result ? depth : 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 result;
    void MaxDepth_qianxuhuisu(TreeNode *node,int depth){
        result = depth > result?depth:result;
        if(node->left == nullptr && node->right == nullptr)return;
        
        if(node->left != nullptr){
            depth++;
            MaxDepth_qianxuhuisu(node->left,depth);
            depth--;
        }
        if(node->right != nullptr){
            depth++;
            MaxDepth_qianxuhuisu(node->right,depth);
            depth--;
        }
        return;
    }
    int maxDepth(TreeNode* root) {
        result = 0;
        if(root == nullptr)return result;
        MaxDepth_qianxuhuisu(root,1);
        return result;
    }
};

 111.二叉树的最小深度 （优先掌握递归）

学：前序求深度，后序求高度。

重点在于当左子树空，右子树不空的时候，深度为1 + 右子树深度

右子树空，左子树不空的时候，深度为1 + 左子树深度

最后如果左右子树都不为空，返回左右子树深度最小值+1

/**
 * 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 == nullptr)return 0;
        int leftDepth = getdepth(node->left);
        int rightDepth = getdepth(node->right);
        //中开始做判断
        if(node ->left == nullptr && node->right != nullptr){
            return 1 + rightDepth;
        }
        if(node->right == nullptr && node ->left != nullptr){
            return 1 + leftDepth;
        }
        int result = 1 + min(leftDepth,rightDepth);
        return result;
    }
    int minDepth(TreeNode* root) {
        return getdepth(root);
    }
};

前序法可以尝试一下（中左右和中右左实际上是一样的）：

/**
 * 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){
        if(node == nullptr)return;
        if(node->left == nullptr && node->right == nullptr){
            result = min(result,depth);
        }
        if(node->right) getdepth(node->right,depth + 1);
        if(node->left) getdepth(node->left,depth + 1);
        return;
    }
    int minDepth(TreeNode* root) {
        if(root == nullptr)return 0;
        result = INT_MAX;
        getdepth(root,1);
        return result;
    }
};

222.完全二叉树的节点个数（优先掌握递归）

遍历的顺序为后序（左右中）

哭了，写出来一个真不容易。

/**
 * 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 getNodesNum(TreeNode *node){
        if(node == nullptr)return 0;
        //左右中
        int leftsum = 0;
        int rightsum = 0;
        if(node->left){
            leftsum = getNodesNum(node->left);
        }
        if(node->right){
            rightsum = getNodesNum(node->right);
        }
        return (1 + leftsum + rightsum);
    }
    int countNodes(TreeNode* root) {
        return getNodesNum(root);
    }
};

迭代法先略过。

了解完全二叉树之后，要换种思路，但其实完全二叉树属于很极端的情况啊感觉，不太有普适性。这个当扩展用吧

return （2<<leftdepth）- 1，要考虑优先级

/**
 * Definition for a binary tree root.
 * 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 == nullptr)return 0;
        TreeNode *left = root->left;
        TreeNode *right = root->right;
        int leftdepth = 0,rightdepth = 0;
        while(left)
        {
            left = left->left;
            leftdepth++;
        }
        while(right)
        {
            right = right->right;
            rightdepth++;
        }
        if(leftdepth == rightdepth) return (2 << leftdepth) - 1;
        int leftsum = countNodes(root->left);
        int rightsum = countNodes(root->right);
        return (1 + leftsum + rightsum);
    }
};

gg，困死我了真心的