LeetCode104. 二叉树的最大深度

104. 二叉树的最大深度

---

一、题目

给定一个二叉树，找出其最大深度。

二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。

说明: 叶子节点是指没有子节点的节点。

示例：
给定二叉树 [3,9,20,null,null,15,7]，

    3
   / \
  9  20
    /  \
   15   7

返回它的最大深度 3 。

二、题解

方法一：递归

算法思路：

我们要求一棵二叉树的最大深度，即从根节点到最远叶子节点的最长路径上的节点数。我们可以利用递归的思想来解决这个问题。从根节点开始，我们分别计算左子树和右子树的最大深度，然后取两者的较大值，并将其加上1，即为当前节点所在子树的最大深度。

我们可以把问题拆解为几个子问题：

1. 如果当前节点为空（即为叶子节点的下一层），那么深度为0。
2. 否则，我们需要递归地求解左子树和右子树的最大深度。
3. 然后取左右子树深度的较大值，再加上1，就得到当前节点所在子树的最大深度。

具体实现：

在具体实现上，我们可以按照上述思路编写代码。首先，我们要定义好二叉树的节点结构，这里题目已经给出了定义。接下来，我们创建一个递归函数 maxDepth 来计算二叉树的最大深度。

/**
 * 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) {
        // 基本情况:如果当前节点为空，则深度为0
        if (root == nullptr) return 0;
        
        // 递归地计算左子树的深度
        int leftDepth = maxDepth(root->left);
        
        // 递归地计算右子树的深度
        int rightDepth = maxDepth(root->right);
        
        //返回左右子树的最大深度加1
        return max(leftDepth, rightDepth) + 1;
    }
};

算法分析：

现在我们来分析一下这个算法的复杂度。

1. 时间复杂度：每个节点都会被访问一次，所以时间复杂度为O(N)，其中N是二叉树的节点数。
2. 空间复杂度：递归函数调用会占用一定的栈空间，而在递归深度方面，最坏情况下（二叉树为单链），递归深度为树的高度，所以空间复杂度为O(H)，其中H为二叉树的高度。在最好情况下（完全平衡二叉树），树的高度为log(N)，在最坏情况下（非平衡二叉树），树的高度为N，因此空间复杂度在O(logN)到O(N)之间。

方法二：迭代

算法思路：

我们也可以利用广度优先搜索（BFS）来解决。广度优先搜索是一种逐层遍历的方法，我们可以在遍历的过程中记录树的深度。我们从根节点开始，将其入队，然后在队列不为空的情况下进行循环操作，每次循环遍历当前队列中的所有节点，将它们的子节点入队。每完成一轮循环，即遍历完当前层的所有节点，我们增加深度计数器，并继续下一轮循环。直到队列中的所有节点都被处理完毕，整个过程结束，此时深度计数器的值就是二叉树的最大深度。

具体实现：

为了实现上述算法思路，我们首先定义二叉树的节点结构 TreeNode。然后，我们使用一个队列 que 来辅助我们进行广度优先搜索。我们将根节点入队，然后通过循环遍历队列中的节点，将它们的子节点入队，并不断更新深度计数器 depth。最后，当队列为空时，我们返回 depth 即为二叉树的最大深度。

/**
 * 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 == nullptr) return 0; // 空树深度为0
        
        int depth = 0; // 初始化深度为0
        queue<TreeNode*> que; // 创建一个队列用于BFS
        que.push(root); // 将根节点入队
        
        while (!que.empty()) { // 进行BFS
            int size = que.size(); // 当前层的节点数
            while (size--) { // 遍历当前层的所有节点
                TreeNode* node = que.front();
                que.pop();
                
                if (node->left) que.push(node->left); // 将左子节点入队
                if (node->right) que.push(node->right); // 将右子节点入队
            }
            depth++; // 记录深度，每层遍历结束后加1
        }
        
        return depth; // 返回最大深度
    }
};

算法分析：

在分析这个算法的复杂度时，我们可以得出以下结论：

1. 时间复杂度：对于一颗有N个节点的二叉树，每个节点都会被访问一次，因为每个节点都会入队一次，并且最多出队一次。因此，时间复杂度为O(N)。
2. 空间复杂度：在最坏情况下（完全二叉树），队列中最多会包含一层的节点数，即为N/2个节点，因此空间复杂度为O(N/2)，近似于O(N)。