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

LeetCode 104. 二叉树的最大深度

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

思路：
本题目的迭代法可以参考上一篇文章代码随想录算法训练营第十五天|102. 二叉树的层序遍历，用的是层序遍历的模板，思路比较简单，仅需要在遍历每一层的时候增加一个深度即可。这道题同样可以用递归的办法做，这里选用了后序遍历，也就是先遍历左节点和右节点，先遍历到最底层，然后取左节点的子树和右节点的子树的最大深度一层一层往上加直到返回根节点。

代码：

class Solution {
public:
    int maxDepth(TreeNode* root) {
        return dfs(root);
    }
    int dfs(TreeNode* root)
    {
        if (root == nullptr)
        {
            return 0;
        }
        int leftTree = dfs(root->left);
        int rightTree = dfs(root->right)
        int depth = 1 + max(leftTree, rightTree);
        return depth;
    }
};

其实代码可以简化很多，这样写只是为了让逻辑更清晰，实际上整个函数只需要以下三行代码

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

可以这样理解最后一行代码：maxDepth()这个函数是为了寻找以root节点为根节点的子树的最大深度，递归调用的第一层把根节点的左节点当作一个子树，右节点当作另一个子树，然后求两者的最大值再加1就是整个树的最大深度了。

附：LeetCode 559. N 叉树的最大深度

链接：559. N 叉树的最大深度

思路：

和二叉树完全一样的思路，需要改的地方仅仅是把左右两个节点的子树改成n个节点的子树，然后求它们的最大深度是多少，其他部分完全一致。

代码：

class Solution {
public:
    int maxDepth(Node* root) {
        int depth = 0;
        return dfs(root, depth);
    }
    int dfs(Node* root, int &depth)
    {
        if (root == nullptr)
            return 0;
        int MAX = 0;
        for (Node* node : root->children)
        {
            MAX = max(MAX, dfs(node));
        }
        int depth = 1 + MAX;
        return depth;
    }
};

LeetCode 111. 二叉树的最小深度

链接：111. 二叉树的最小深度

思路：

和最大深度比逻辑稍微复杂了些，首先既然求的是最小深度，我们可以把max(leftTree, rightTree)直接改成min(leftTree, rightTree)， 但是这种情况仅限于左右两个子树都不为空的时候，当有任意一颗子树为空，那么它的深度就直接变为0了，这显然不是我们想要的。只要其中一个子树不为空，我们就要递归的寻找下去。当前节点的深度则等于不为空的那个子节点组成的子树的最小深度+1，如：左子树为空，返回右子树最小深度+1，右子树为空，返回左子树最小深度+1。

代码：

class Solution {
public:
    int minDepth(TreeNode* root) {
        if (root == nullptr)
            return 0;
        else if (root->left == nullptr) // 左子树为空，返回右子树最小深度+1
            return 1 + minDepth(root->right);
        else if (root->right == nullptr)
            return 1 + minDepth(root->left); // 右子树为空，返回左子树最小深度+1
        else
        {
            return 1 + min(minDepth(root->left), minDepth(root->right)); // 都不为空，返回左右子树最小深度+1
        }
    }
};

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

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

写法一：

思路：

可以按照前序遍历的思路，每经过一个节点count+1就行，这种方法适用于所有的树。

代码：

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

写法二：

思路：

利用完全二叉树的性质：如果一棵完全二叉树是满二叉树，那么它的节点数量等于2^i-1，i为满二叉树的深度。如果完全二叉树不是满二叉树，那么这说明它的最后一层的叶子节点并不完整，但是它的子树一定是完全二叉树，如下图

 所以可以用递归的方法，当一颗树不是满二叉树的时候，就寻找它的子树，判断它的子树是否是满二叉树，如此往复下去直到找到一颗满二叉树为止。那么如何判断一颗完全二叉树是否是满二叉树呢，很简单，只需要分别往左和往右遍历子节点到最底层然后计算深度即可，如果左右节点的深度一样，则是满二叉树，如下图所示。

 如果递归向左遍历的深度和递归向右遍历的深度不一样，则不是满二叉树

 注意完全二叉树的定义，以下情况虽然左右节点深度一样，但它不是完全二叉树

 

代码：

class Solution {
public:
    int countNodes(TreeNode* root) {
        if (root == nullptr)
            return 0;
        return completeTree(root);
    }
    int getDepth(TreeNode* root, bool dir)
    {
        if (root == nullptr)
            return 0;
        if (dir)
            return 1 + getDepth(root->left, dir);
        else
            return 1 + getDepth(root->right, dir);
            
    }
    int completeTree(TreeNode* root)
    {
        if (root == nullptr)
            return 0;
        int leftNodes = getDepth(root, 0);
        // 如果是满二叉树，则直接计算并节点数
        if (leftNodes == getDepth(root, 1))
            return pow(2, leftNodes) - 1;
        else
            // 如果不是满二叉树，通过递归计算左右两颗子树的节点并+1
            return 1 + completeTree(root->left) + completeTree(root->right);
    }
};

时间复杂度：O(logn x logn)

空间复杂度：O(logn)