404. Sum of Left Leaves – Leetcode Solutions

Example 1:

Input: root = [3,9,20,null,null,15,7]
Output: 24
Explanation: There are two left leaves in the binary tree, with values 9 and 15 respectively.

Example 2:

Input: root = [1]
Output: 0

class Solution:
    def sumOfLeftLeaves(self, root: Optional[TreeNode]) -> int:
        # Helper function to check if a node is a leaf
        def isLeaf(node):
            return node is not None and node.left is None and node.right is None
        
        # Base case: if the root is None, return 0
        if root is None:
            return 0
        
        # Initialize sum
        total = 0
        
        # Check if the left child is a leaf
        if root.left and isLeaf(root.left):
            total += root.left.val
        
        # Recursively compute the sum of left leaves in the left and right subtrees
        total += self.sumOfLeftLeaves(root.left)
        total += self.sumOfLeftLeaves(root.right)
        
        return total

class Solution {
public:
    // Function to calculate the sum of all left leaves in a binary tree.
    int sumOfLeftLeaves(TreeNode* root) {
        // If the root is null, there are no leaves, so return 0.
        if (!root) {
            return 0;
        }

        int sum = 0;

        // Check if the left child exists and if it's a leaf node.
        if (root->left && !root->left->left && !root->left->right) {
            // Add the value of the left leaf to the sum.
            sum += root->left->val;
        }

        // Recursively calculate the sum of left leaves in the left and right subtrees.
        sum += sumOfLeftLeaves(root->left);
        sum += sumOfLeftLeaves(root->right);

        return sum; // Return the total sum of left leaves.
    }
};

var sumOfLeftLeaves = function(root) {
    // Base case: if the root is null, there is no tree, so return 0
    if (!root) {
        return 0;
    }

    let sum = 0;

    // Check if the left child exists and is a leaf
    if (root.left && !root.left.left && !root.left.right) {
        // Add the value of the left leaf to the sum
        sum += root.left.val;
    }

    // Recursively calculate the sum of left leaves in the left and right subtrees
    sum += sumOfLeftLeaves(root.left);
    sum += sumOfLeftLeaves(root.right);

    // Return the total sum of left leaves
    return sum;
};

class Solution {
    public int sumOfLeftLeaves(TreeNode root) {
        // Base case: If the tree is empty, return 0.
        if (root == null) {
            return 0;
        }

        int sum = 0;

        // Check if the left child exists and is a leaf node.
        if (root.left != null) {
            // A leaf node is defined as having no children (both left and right are null).
            if (root.left.left == null && root.left.right == null) {
                sum += root.left.val; // Add the value of the left leaf node to the sum.
            }
        }

        // Recursively calculate the sum of left leaves in the left and right subtrees.
        sum += sumOfLeftLeaves(root.left);
        sum += sumOfLeftLeaves(root.right);

        // Return the accumulated sum.
        return sum;
    }
}