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

1.1 104.二叉树的最大深度

思路：

1. 采用后序遍历
2. 确定递归函数的参数和返回值，确定终止条件，确定单层递归的逻辑

class solution {
public:
    int getdepth(TreeNode* node) {
        if (node == NULL) 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);
    }
};

思路：

1. 采用前序遍历
2. 深度回溯的过程

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;
    }
};

1.2 559.n叉树的最大深度

思路：

1. 递归法
2. 注意函数返回的是以该节点起接着往下的深度

class Solution {
private:
    int getdepth(Node* node){
        if(node == nullptr) return 0;
        int size = node->children.size();
        int depth = 0;
        for(int i = 0; i < size; ++i){
            depth = max(depth, getdepth(node->children[i]));
        }
        return depth + 1;
    }
public:
    int maxDepth(Node* root) {
        return getdepth(root);
    }
};

思路：

1. 迭代法（层序遍历）

class solution {
public:
    int maxDepth(Node* root) {
        queue<Node*> que;
        if (root != NULL) que.push(root);
        int depth = 0;
        while (!que.empty()) {
            int size = que.size();
            depth++; // 记录深度
            for (int i = 0; i < size; i++) {
                Node* node = que.front();
                que.pop();
                for (int j = 0; j < node->children.size(); j++) {
                    if (node->children[j]) que.push(node->children[j]);
                }
            }
        }
        return depth;
    }
};

1.3 111.二叉树的最小深度

思路：

1. 递归法
2. 注意如何处理只有一边有孩子的情况，只有左右孩子都为空的节点才是叶子节点

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);
    }
};

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

思路：

1. 递归
2. 后序遍历

class Solution {
private:
    int getNum(TreeNode* node){
        if(node == nullptr) return 0;
        int leftSum = getNum(node->left);
        int rightSum = getNum(node->right);
        return leftSum + rightSum + 1;
    }
public:
    int countNodes(TreeNode* root) {
        return getNum(root);
    }
};

• 时间复杂度：O(n)
• 空间复杂度：O(log n)，算上了递归系统栈占用的空间

思路：

1. 考虑完全二叉树的特性

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)

1.5 补充

递归的复杂度：

迭代的复杂度：