LeetCode559. N 叉树的最大深度

559. N 叉树的最大深度

---

一、题目

给定一个 N 叉树，找到其最大深度。

最大深度是指从根节点到最远叶子节点的最长路径上的节点总数。

N 叉树输入按层序遍历序列化表示，每组子节点由空值分隔（请参见示例）。

示例 1：

输入：root = [1,null,3,2,4,null,5,6]
输出：3

示例 2：

输入：root = [1,null,2,3,4,5,null,null,6,7,null,8,null,9,10,null,null,11,null,12,null,13,null,null,14]
输出：5

提示：

• 树的深度不会超过 1000 。
• 树的节点数目位于 [0, 104] 之间。

二、题解

方法一：迭代

题目要求计算一棵多叉树的最大深度，也就是树的高度。我们可以使用广度优先搜索（BFS）来解决这个问题。让我们一步一步地详细解释这个算法。

算法思路

1. 我们从根节点开始，使用队列来进行广度优先搜索。
2. 首先将根节点入队，然后进入循环，直到队列为空。
3. 在循环中，我们首先记录当前队列中的节点个数（这是因为在每一层循环时，队列中的节点都属于同一层，我们需要控制循环的次数）。
4. 接下来，我们对当前层的所有节点进行处理：
   • 从队列中取出一个节点，然后将它的子节点（如果有的话）入队。
   • 在处理完当前层的所有节点后，我们的深度+1，表示我们进入了下一层。
   • 继续下一次循环，直到队列为空，这时候我们遍历完了整个多叉树，并得到了最大深度。

具体实现

class Solution {
public:
    int maxDepth(Node* root) {
        // 创建一个队列用于广度优先搜索
        queue<Node*> que;
        
        // 如果根节点非空，则将根节点入队
        if (root != nullptr)
            que.push(root);
        
        // 初始化深度为0
        int depth = 0;
        
        // 开始广度优先搜索
        while (!que.empty()) {
            // 记录当前层的节点个数
            int size = que.size();
            
            // 处理当前层的所有节点
            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]);
                }
            }
            
            // 当前层的节点处理完毕，深度+1，表示进入下一层
            depth++;
        }
        
        // 返回最大深度
        return depth;
    }
};

算法分析

• 时间复杂度: 我们需要遍历所有的节点，每个节点都会被访问一次，因此时间复杂度为O(N)，其中N是树中节点的总数。
• 空间复杂度: 在最坏情况下，队列中最多会存储一层的节点，因此空间复杂度为O(W)，其中W是树的最大宽度（即同一层节点的最大数量）。在最好情况下，树为平衡树，此时宽度W将接近N/2，因此空间复杂度可以近似看作O(N)。

方法二：递归

算法思路

1. 首先，我们判断根节点是否为空。如果根节点为空，说明树是空的，深度为0，直接返回0作为结果。
2. 如果根节点不为空，我们需要对每个子节点进行递归调用。在这个过程中，我们将每个子节点看作根节点，计算其子树的最大深度。
3. 通过递归调用，我们能够计算出所有子树的最大深度，然后从中选取最大的一个作为当前树的最大深度。
4. 最终，树的最大深度等于其最深的子树深度加1。

具体实现

class Solution {
public:
    int maxDepth(Node* root) {
        // 如果根节点为空，返回深度为0
        if (root == nullptr) return 0;
        
        // 获取根节点的子节点个数
        int n = root->children.size();
        
        // 初始化最大深度为0
        int max = 0;
        
        // 遍历根节点的所有子节点
        for (int i = 0; i < n; i++) {
            // 递归调用maxDepth函数，计算当前子节点的最大深度
            int Depth = maxDepth(root->children[i]);
            
            // 选取最大的子节点深度作为当前树的最大深度
            if (Depth > max) {
                max = Depth;
            }
        }
        
        // 返回当前树的最大深度加1
        return max + 1;
    }
};

算法分析

• 时间复杂度: 由于每个节点都会被访问一次且只访问一次，递归调用的次数是节点的总数N，因此时间复杂度为O(N)。
• 空间复杂度: 递归调用的深度取决于树的高度，而树的高度为最大深度。在最坏情况下，树为单链表形式，高度接近N，因此空间复杂度为O(N)。在最好情况下，树为平衡树，高度为log(N)，此时空间复杂度为O(logN)。