【1302. 层数最深叶子节点的和】

来源：力扣（LeetCode）

描述：

给你一棵二叉树的根节点 root ，请你返回 层数最深的叶子节点的和 。

示例 1：

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

示例 2：

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

提示：

• 树中节点数目在范围 [1, 10⁴] 之间。

• 1 <= Node.val <= 100

方法一：深度优先搜索

由于层数最深的节点一定是叶节点，因此只要找到所有层数最深的节点并计算节点值之和即可。

可以使用深度优先搜索实现。从根节点开始遍历整个二叉树，遍历每个节点时需要记录该节点的层数，规定根节点在第 0 层。遍历过程中维护最大层数与最深节点之和。

对于每个非空节点，执行如下操作。

• 1 、判断当前节点的层数与最大层数的关系：

  • 如果当前节点的层数大于最大层数，则之前遍历到的节点都不是层数最深的节点，因此用当前节点的层数更新最大层数，并将最深节点之和更新为当前节点值；
  • 如果当前节点的层数等于最大层数，则将当前节点值加到最深节点之和。

• 2、对当前节点的左右子节点继续深度优先搜索。

遍历结束之后，即可得到层数最深叶子节点的和。

代码：

class Solution {
private:
    int maxLevel = -1;
    int sum = 0;

public:
    int deepestLeavesSum(TreeNode* root) {
        dfs(root, 0);
        return sum;
    }

    void dfs(TreeNode* node, int level) {
        if (node == nullptr) {
            return;
        }
        if (level > maxLevel) {
            maxLevel = level;
            sum = node->val;
        } else if (level == maxLevel) {
            sum += node->val;
        }
        dfs(node->left, level + 1);
        dfs(node->right, level + 1);
    }
};

执行用时：84 ms, 在所有 C++ 提交中击败了78.19%的用户
内存消耗：58.3 MB, 在所有 C++ 提交中击败了91.63%的用户
复杂度分析
时间复杂度：O(n)，其中 n 是二叉树的节点数。深度优先搜索需要遍历每个节点一次。
空间复杂度：O(n)，其中 n 是二叉树的节点数。空间复杂度主要取决于递归调用栈的深度，为二叉树的深度，最坏情况下二叉树的深度是 O(n)。

方法二：广度优先搜索

计算最深节点之和也可以使用广度优先搜索实现。使用广度优先搜索时，对二叉树层序遍历，此时不需要维护最大层数，只需要确保每一轮遍历的节点是同一层的全部节点，则最后一轮遍历的节点是全部最深节点。

初始时，将根节点加入队列，此时队列中只有一个节点，是同一层的全部节点。每一轮遍历时，首先得到队列中的节点个数 size，从队列中取出 size 个节点，则这 size 个节点是同一层的全部节点，记为第 x 层。遍历时，第 x 层的每个节点的子节点都在第 x + 1 层，将子节点加入队列，则该轮遍历结束之后，第 x 层的节点全部从队列中取出，第 x + 1 层的节点全部加入队列，队列中的节点是同一层的全部节点。因此该方法可以确保每一轮遍历的节点是同一层的全部节点。

遍历过程中，分别计算每一层的节点之和，则遍历结束时的节点之和即为层数最深叶子节点的和。

代码：

class Solution {
public:
    int deepestLeavesSum(TreeNode* root) {
        int sum = 0;
        queue<TreeNode*> qu;
        qu.emplace(root);
        while (!qu.empty()) {
            sum = 0;
            int size = qu.size();
            for (int i = 0; i < size; i++) {
                TreeNode *node = qu.front();
                qu.pop();
                sum += node->val;
                if (node->left != nullptr) {
                    qu.emplace(node->left);
                }
                if (node->right != nullptr) {
                    qu.emplace(node->right);
                }
            }
        }
        return sum;
    }
};

执行用时：84 ms, 在所有 C++ 提交中击败了78.19%的用户
内存消耗：60.3 MB, 在所有 C++ 提交中击败了37.86%的用户
复杂度分析
时间复杂度： O(n)，其中 n 是二叉树的节点数。广度优先搜索需要遍历每个节点一次。
空间复杂度： O(n)，其中 n 是二叉树的节点数。空间复杂度主要取决于队列空间，队列中的节点个数不超过 n 个。
author：LeetCode-Solution