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

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

104.二叉树的最大深度

代码如下（示例）：

递归法：

class solution {
public:
    int maxdepth(treenode* root) {
        if (node == NULL) return 0;
        int leftdepth = getdepth(node->left);       // 左
        int rightdepth = getdepth(node->right);     // 右
        int depth = 1 + max(leftdepth, rightdepth); // 中
        return depth;
    }
};

前序遍历：

class Solution {
public:    
    int result;
    void getdepth(TreeNode* node, int depth) {
        if(node == nullptr ) return;
        depth++;
        result = depth > result ? depth : result; // 中

        getdepth(node->left, depth);
        getdepth(node->right, depth);
    }
    int maxDepth(TreeNode* root) {
        result = 0;
        getdepth(root, 0);
        return result;
    }
};

自己写的，用result保存最终结果，不用回溯；

回溯法：

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) { // 左
            depth++;    // 深度+1
            getdepth(node->left, depth);
            depth--;    // 回溯，深度-1
        }
        if (node->right) { // 右
            depth++;    // 深度+1
            getdepth(node->right, depth);
            depth--;    // 回溯，深度-1
        }
        return ;
    }
    int maxdepth(treenode* root) {
        result = 0;
        if (root == NULL) return result;
        getdepth(root, 1);
        return result;
    }
};

111.二叉树的最小深度

代码如下（示例）：

递归法：

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

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

要求时间复杂度小于n

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; // 这里初始为0是有目的的，为了下面求指数方便
        while (left) {  // 求左子树深度
            left = left->left;
            leftDepth++;
        }
        while (right) { // 求右子树深度
            right = right->right;
            rightDepth++;
        }
        if (leftDepth == rightDepth) {
            return (2 << leftDepth) - 1; // 注意(2<<1) 相当于2^2，所以leftDepth初始为0
        }
        return countNodes(root->left) + countNodes(root->right) + 1;
    }
};
时间复杂度：O(log n × log n)
空间复杂度：O(log n)

这个时间复杂度为什么是logN我还没有想清楚。。。
现在搞明白了，只有logN-1~logN个节点是需要计数的。图中的子树中的满二叉树直接根据公式计算得出。