leetcode之层数最深叶子节点的和（C++）

参考链接

1. https://leetcode-cn.com/problems/deepest-leaves-sum/
2. https://leetcode-cn.com/problems/deepest-leaves-sum/solution/ceng-shu-zui-shen-xie-zi-jie-dian-de-he-by-leetc-2/

题目描述

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

解题思路

可以对整棵树遍历一次（前序、中序、后序皆可），利用哈希表记录深度与节点值的映射，最后再将哈希表里最大深度对应的所有节点值求和。但效率是很低的，可以一边遍历一边求和。

也可以使用深度优先搜索或广度优先搜索。

代码

使用哈希表

class Solution {
public:
    unordered_map<int, vector<int>> mp;
    int max_deepth = 0;
    int res = 0;
    int deepestLeavesSum(TreeNode* root) {
        traverse(root, 0);
        for (int num : mp[max_deepth])
        {
            res += num;
        }
        return res;
    }
    void traverse(TreeNode* root, int deepth)
    {
        if (root == nullptr)
        {
            return;
        }
        max_deepth = max(max_deepth, deepth);
        mp[deepth].push_back(root->val);
        traverse(root->left, deepth + 1);
        traverse(root->right, deepth + 1);
    }
};

深度优先搜索

class Solution {
private:
    int maxdep = -1;
    int total = 0;

public:
    void dfs(TreeNode* node, int dep) {
        if (!node) {
            return;
        }
        if (dep > maxdep) {
            maxdep = dep;
            total = node->val;
        }
        else if (dep == maxdep) {
            total += node->val;
        }
        dfs(node->left, dep + 1);
        dfs(node->right, dep + 1);
    }

    int deepestLeavesSum(TreeNode* root) {
        dfs(root, 0);
        return total;
    }
};

广度优先搜索

using PTI = pair<TreeNode*, int>;

class Solution {
public:
    int deepestLeavesSum(TreeNode* root) {
        queue<PTI> q;
        q.emplace(root, 0);
        int maxdep = -1, total = 0;
        while (!q.empty()) {
            TreeNode* node = q.front().first;
            int dep = q.front().second;
            q.pop();
            if (dep > maxdep) {
                maxdep = dep;
                total = node->val;
            }
            else if (dep == maxdep) {
                total += node->val;
            }
            if (node->left) {
                q.emplace(node->left, dep + 1);
            }
            if (node->right) {
                q.emplace(node->right, dep + 1);
            }
        }
        return total;
    }
};