Approach: BFS level by level; keep the last level sum

def deepestLeavesSum(self, root):
    from collections import deque
    q = deque([root]); s = 0
    while q:
        s = 0
        for _ in range(len(q)):
            n = q.popleft(); s += n.val
            if n.left: q.append(n.left)
            if n.right: q.append(n.right)
    return s

Complexity: O(n) time, O(w) space.

Full Solution — all languages

class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

class Solution:
    def deepestLeavesSum(self, root):
        from collections import deque
        q = deque([root]); s = 0
        while q:
            s = 0
            for _ in range(len(q)):
                n = q.popleft(); s += n.val
                if n.left: q.append(n.left)
                if n.right: q.append(n.right)
        return s

import java.util.*;
class TreeNode {
    int val;
    TreeNode left, right;
    TreeNode(int v) {
        val = v;
    }
}
class Solution {
    public int deepestLeavesSum(TreeNode root) {
        Queue<TreeNode> q = new LinkedList<>();
        q.add(root);
        int s = 0;
        while (!q.isEmpty()) {
            int sz = q.size();
            s = 0;
            for (int i = 0; i < sz; i++) {
                TreeNode n = q.poll();
                s += n.val;
                if (n.left != null) q.add(n.left);
                if (n.right != null) q.add(n.right);
            }
        }
        return s;
    }
}

#include <bits/stdc++.h> using namespace std;
struct TreeNode {
    int val;
    TreeNode *left, *right;
    TreeNode(int v): val(v), left(nullptr), right(nullptr) {
    }
};
class Solution {
    public: int deepestLeavesSum(TreeNode* root) {
        queue<TreeNode*> q;
        q.push(root);
        int s = 0;
        while (!q.empty()) {
            int sz = q.size();
            s = 0;
            for (int i = 0; i < sz; i++) {
                TreeNode* n = q.front();
                q.pop();
                s += n->val;
                if (n->left) q.push(n->left);
                if (n->right) q.push(n->right);
            }
        }
        return s;
    }
};

/**
 * Tree node shape: { val, left, right }
 * @param {TreeNode} root
 * @return {number}
 */ var deepestLeavesSum = function(root) {
    let q = [root], s = 0;
    while (q.length) {
        const nq = [];
        s = 0;
        for (const n of q) {
            s += n.val;
            if (n.left) nq.push(n.left);
            if (n.right) nq.push(n.right);
        }
        q = nq;
    }
    return s;
};

Deepest Leaves Sum

Example 1

Example 2

Constraints