Sum of Left Leaves - Practice Coding Problems

Sum of Left Leaves - Problem

Given the root of a binary tree, your task is to find and return the sum of all left leaves.

A leaf is a node that has no children (both left and right children are null). A left leaf is specifically a leaf node that is the left child of its parent.

Important: Not all leaves count! Only those leaves that are left children of their parent nodes should be included in the sum.

Example: In a tree where node 5 has a left child 9 (which is a leaf) and a right child 1, only the value 9 would contribute to our sum since it's a left leaf.

Input & Output

example_1.py — Basic Tree

$ Input: [3,9,20,null,null,15,7]

› Output: 24

💡 Note: The tree has two leaves: 9 (left child of 3) and 7 (right child of 20). Only node 9 is a left leaf, so the sum is 9. Wait, let me recalculate... Actually, node 15 is a left child of 20 and is a leaf, so the sum should include 15. The sum is 24.

example_2.py — Single Node

$ Input: [1]

› Output: 0

💡 Note: A single node tree has no left leaves since the root cannot be a left child of any node.

example_3.py — Only Right Children

$ Input: [1,null,2,null,3,null,4]

› Output: 0

💡 Note: This tree has only right children, so there are no left leaves. The sum is 0.

Visualization

Tap to expand

Understanding the Visualization

Start at Root

Begin the journey at the root node, marking it as 'not a left child'

Explore Left Branch

Move to left child and mark it as 'left child', continue recursively

Check Leaf Status

When reaching a node with no children, check if it's marked as 'left child'

Sum Left Leaves

Add values of nodes that are both leaves AND left children

Key Takeaway

🎯 Key Insight: Use DFS with a boolean flag to identify left leaves in a single traversal - when a node is both a leaf AND came from a left path, include it in the sum!

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Multiple passes through the tree, where each pass visits O(n) nodes

⚠ Quadratic Growth

Space Complexity

O(n)

Need to store all leaf nodes and their parent relationships

⚡ Linearithmic Space

Constraints

The number of nodes in the tree is in the range [1, 1000]
Node values are in the range [-1000, 1000]
A leaf node has both left and right children as null

Asked in

f Facebook 15 a Amazon 12 G Google 8 ⊞ Microsoft 6

The optimal approach uses a single DFS traversal with a boolean flag to track whether the current node is a left child. When we encounter a leaf node that is also a left child, we add its value to our running sum. This achieves O(n) time complexity with O(h) space complexity for the recursion stack.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Multiple Tree Traversals)	O(n²)	O(n)	Traverse the tree multiple times to identify and sum left leaves
Single Pass DFS (Optimal)	O(n)	O(h)	Use DFS to identify and sum left leaves in one traversal

Brute Force (Multiple Tree Traversals) — Algorithm Steps

First pass: Identify all leaf nodes in the tree
Second pass: For each leaf, check if it's a left child of its parent
Third pass: Sum up all nodes that are both leaves and left children
Return the total sum

Visualization

Tap to expand

Step-by-Step Walkthrough

First Pass

Identify all leaf nodes (nodes 7, 15, 20)

Second Pass

Check which leaves are left children (only node 15)

Third Pass

Sum up the qualifying left leaves (15)

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
};

struct TreeNode* createNode(int val) {
    struct TreeNode* node = malloc(sizeof(struct TreeNode));
    node->val = val;
    node->left = NULL;
    node->right = NULL;
    return node;
}

void findLeaves(struct TreeNode* node, struct TreeNode** leaves, int* count) {
    if (!node) return;
    if (!node->left && !node->right) {
        leaves[(*count)++] = node;
    }
    findLeaves(node->left, leaves, count);
    findLeaves(node->right, leaves, count);
}

int checkLeftChild(struct TreeNode* node, struct TreeNode* targetLeaf) {
    if (!node) return 0;
    if (node->left == targetLeaf) return 1;
    return checkLeftChild(node->left, targetLeaf) || checkLeftChild(node->right, targetLeaf);
}

int sumOfLeftLeaves(struct TreeNode* root) {
    if (!root) return 0;
    
    // First pass: find all leaf nodes
    struct TreeNode* leaves[1000];
    int leafCount = 0;
    findLeaves(root, leaves, &leafCount);
    
    // Second pass: check which leaves are left children and sum
    int sum = 0;
    for (int i = 0; i < leafCount; i++) {
        if (checkLeftChild(root, leaves[i])) {
            sum += leaves[i]->val;
        }
    }
    
    return sum;
}

struct TreeNode* buildTree(int* arr, int size) {
    if (size == 0) return NULL;
    
    struct TreeNode* root = createNode(arr[0]);
    struct TreeNode* queue[1000];
    int front = 0, rear = 0;
    queue[rear++] = root;
    
    int i = 1;
    while (front < rear && i < size) {
        struct TreeNode* node = queue[front++];
        
        if (i < size && arr[i] != -1) {
            node->left = createNode(arr[i]);
            queue[rear++] = node->left;
        }
        i++;
        
        if (i < size && arr[i] != -1) {
            node->right = createNode(arr[i]);
            queue[rear++] = node->right;
        }
        i++;
    }
    return root;
}

int main() {
    int arr[1000];
    int size = 0;
    
    // Simple input parsing - assumes space-separated integers
    char input[10000];
    fgets(input, sizeof(input), stdin);
    
    char* token = strtok(input, " ,[]\n");
    while (token) {
        if (strcmp(token, "null") == 0) {
            arr[size++] = -1; // Use -1 to represent null
        } else {
            arr[size++] = atoi(token);
        }
        token = strtok(NULL, " ,[]\n");
    }
    
    struct TreeNode* root = buildTree(arr, size);
    printf("%d\n", sumOfLeftLeaves(root));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Multiple passes through the tree, where each pass visits O(n) nodes

⚠ Quadratic Growth

Space Complexity

O(n)

Need to store all leaf nodes and their parent relationships

⚡ Linearithmic Space

Constraints

The number of nodes in the tree is in the range [1, 1000]
Node values are in the range [-1000, 1000]
A leaf node has both left and right children as null

89.6K Views

Medium Frequency

~15 min Avg. Time

2.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Multiple Tree Traversals) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler