Find sum of all left leaves in a given Binary Tree

Given a Binary Tree, find the sum of all left leaves in it. For example, sum of all left leaves in below Binary Tree is 5+1=6.

The idea is to traverse the tree, starting from root. For every node, check if its left subtree is a leaf. If it is, then add it to the result. 
Following is the implementation of the above idea.

C++

// A C++ program to find sum of all left leaves
#include <bits/stdc++.h>
using namespace std;

/* A binary tree Node has key, pointer to left and right
   children */
struct Node
{
    int key;
    struct Node* left, *right;
};

/* Helper function that allocates a new node with the
   given data and NULL left and right pointer. */
Node *newNode(int k)
{
    Node *node = new Node;
    node->key = k;
    node->right = node->left = NULL;
    return node;
}

// A utility function to check if a given node is leaf or not
bool isLeaf(Node *node)
{
   if (node == NULL)
       return false;
   if (node->left == NULL && node->right == NULL)
       return true;
   return false;
}

// This function returns sum of all left leaves in a given
// binary tree
int leftLeavesSum(Node *root)
{
    // Initialize result
    int res = 0;

    // Update result if root is not NULL
    if (root != NULL)
    {
       // If left of root is NULL, then add key of
       // left child
       if (isLeaf(root->left))
            res += root->left->key;
       else // Else recur for left child of root
            res += leftLeavesSum(root->left);

       // Recur for right child of root and update res
       res += leftLeavesSum(root->right);
    }

    // return result
    return res;
}

/* Driver program to test above functions*/
int main()
{
    // Let us a construct the Binary Tree
    struct Node *root         = newNode(20);
    root->left                = newNode(9);
    root->right               = newNode(49);
    root->right->left         = newNode(23);
    root->right->right        = newNode(52);
    root->right->right->left  = newNode(50);
    root->left->left          = newNode(5);
    root->left->right         = newNode(12);
    root->left->right->right  = newNode(12);
    cout << "Sum of left leaves is "
         << leftLeavesSum(root);
    return 0;
}

// This code is contributed by Aditya kumar (adityakumar129)

C

// A C++ program to find sum of all left leaves
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

/* A binary tree Node has key, pointer to left and right
   children */
struct Node
{
  int key;
  struct Node* left, *right;
};

/* Helper function that allocates a new node with the
   given data and NULL left and right pointer. */
struct Node *newNode(int k)
{
  struct Node *node = (struct Node *)malloc(sizeof(struct Node));
  node->key = k;
  node->right = node->left = NULL;
  return node;
}

// A utility function to check if a given node is leaf or not
bool isLeaf(struct Node *node)
{
  if (node == NULL)
    return false;
  if (node->left == NULL && node->right == NULL)
    return true;
  return false;
}

// This function returns sum of all left leaves in a given
// binary tree
int leftLeavesSum(struct Node *root)
{
  // Initialize result
  int res = 0;

  // Update result if root is not NULL
  if (root != NULL)
  {
    // If left of root is NULL, then add key of
    // left child
    if (isLeaf(root->left))
      res += root->left->key;
    else // Else recur for left child of root
      res += leftLeavesSum(root->left);

    // Recur for right child of root and update res
    res += leftLeavesSum(root->right);
  }

  // return result
  return res;
}

/* Driver program to test above functions*/
int main()
{
  // Let us a construct the Binary Tree
  struct Node *root         = newNode(20);
  root->left                = newNode(9);
  root->right               = newNode(49);
  root->right->left         = newNode(23);
  root->right->right        = newNode(52);
  root->right->right->left  = newNode(50);
  root->left->left          = newNode(5);
  root->left->right         = newNode(12);
  root->left->right->right  = newNode(12);
  printf("Sum of left leaves is %d",leftLeavesSum(root));
  return 0;
}

// This code is contributed by Aditya kumar (adityakumar129)

Java

// Java program to find sum of all left leaves
class Node
{
    int data;
    Node left, right;

    Node(int item)
    {
        data = item;
        left = right = null;
    }
}

class BinaryTree
{
    Node root;

    // A utility function to check if a given node is leaf or not
    boolean isLeaf(Node node)
    {
        if (node == null)
            return false;
        if (node.left == null && node.right == null)
            return true;
        return false;
    }

     // This function returns sum of all left leaves in a given
     // binary tree
    int leftLeavesSum(Node node)
    {
        // Initialize result
        int res = 0;

        // Update result if root is not NULL
        if (node != null)
        {
            // If left of root is NULL, then add key of
            // left child
            if (isLeaf(node.left))
                res += node.left.data;
            else // Else recur for left child of root
                res += leftLeavesSum(node.left);

            // Recur for right child of root and update res
            res += leftLeavesSum(node.right);
        }

        // return result
        return res;
    }

    // Driver program
    public static void main(String args[])
    {
        BinaryTree tree = new BinaryTree();
        tree.root = new Node(20);
        tree.root.left = new Node(9);
        tree.root.right = new Node(49);
        tree.root.left.right = new Node(12);
        tree.root.left.left = new Node(5);
        tree.root.right.left = new Node(23);
        tree.root.right.right = new Node(52);
        tree.root.left.right.right = new Node(12);
        tree.root.right.right.left = new Node(50);

        System.out.println("The sum of leaves is " +
                                       tree.leftLeavesSum(tree.root));
    }
}

// This code is contributed by Mayank Jaiswal

Python3

# Python program to find sum of all left leaves

# A Binary tree node
class Node:
    # Constructor to create a new Node
    def __init__(self, key):
        self.key = key
        self.left = None
        self.right = None

# A utility function to check if a given node is leaf or not
def isLeaf(node):
    if node is None:
        return False
    if node.left is None and node.right is None:
        return True
    return False

# This function return sum of all left leaves in a
# given binary tree
def leftLeavesSum(root):

    # Initialize result
    res = 0

    # Update result if root is not None
    if root is not None:

        # If left of root is None, then add key of
        # left child
        if isLeaf(root.left):
            res += root.left.key
        else:
            # Else recur for left child of root
            res += leftLeavesSum(root.left)

        # Recur for right child of root and update res
        res += leftLeavesSum(root.right)
    return res

# Driver program to test above function

# Let us construct the Binary Tree shown in the above function
root = Node(20)
root.left = Node(9)
root.right = Node(49)
root.right.left = Node(23)
root.right.right = Node(52)
root.right.right.left = Node(50)
root.left.left = Node(5)
root.left.right = Node(12)
root.left.right.right = Node(12)
print ("Sum of left leaves is", leftLeavesSum(root))

# This code is contributed by Nikhil Kumar Singh(nickzuck_007)

C#

using System;

// C# program to find sum of all left leaves
public class Node
{
    public int data;
    public Node left, right;

    public Node(int item)
    {
        data = item;
        left = right = null;
    }
}

public class BinaryTree
{
    public Node root;

    // A utility function to check if a given node is leaf or not
    public virtual bool isLeaf(Node node)
    {
        if (node == null)
        {
            return false;
        }
        if (node.left == null && node.right == null)
        {
            return true;
        }
        return false;
    }

     // This function returns sum of all left leaves in a given
     // binary tree
    public virtual int leftLeavesSum(Node node)
    {
        // Initialize result
        int res = 0;

        // Update result if root is not NULL
        if (node != null)
        {
            // If left of root is NULL, then add key of
            // left child
            if (isLeaf(node.left))
            {
                res += node.left.data;
            }
            else // Else recur for left child of root
            {
                res += leftLeavesSum(node.left);
            }

            // Recur for right child of root and update res
            res += leftLeavesSum(node.right);
        }

        // return result
        return res;
    }

    // Driver program
    public static void Main(string[] args)
    {
        BinaryTree tree = new BinaryTree();
        tree.root = new Node(20);
        tree.root.left = new Node(9);
        tree.root.right = new Node(49);
        tree.root.left.right = new Node(12);
        tree.root.left.left = new Node(5);
        tree.root.right.left = new Node(23);
        tree.root.right.right = new Node(52);
        tree.root.left.right.right = new Node(12);
        tree.root.right.right.left = new Node(50);

        Console.WriteLine("The sum of leaves is " + tree.leftLeavesSum(tree.root));
    }
}

  //  This code is contributed by Shrikant13

Javascript

<script>
// Javascript program to find sum of all left leaves

    class Node
    {
        constructor(k)
        {
            this.data = k;
            this.left = null;
            this.right = null;
        }

    }

    // A utility function to check if a given node is leaf or not
    function isLeaf(node)
    {
        if (node == null)
            return false;
        if (node.left == null && node.right == null)
            return true;
        return false;
    }

    // This function returns sum of all left leaves in a given
     // binary tree
    function leftLeavesSum(node)
    {

        // Initialize result
        let res = 0;

        // Update result if root is not NULL
        if (node != null)
        {

            // If left of root is NULL, then add key of
            // left child
            if (isLeaf(node.left))
                res += node.left.data;
            else // Else recur for left child of root
                res += leftLeavesSum(node.left);

            // Recur for right child of root and update res
            res += leftLeavesSum(node.right);
        }

        // return result
        return res;
    }

    // Driver program
    root = new Node(20);
    root.left = new Node(9);
    root.right = new Node(49);
    root.left.right = new Node(12);
    root.left.left = new Node(5);
    root.right.left = new Node(23);
    root.right.right = new Node(52);
    root.left.right.right = new Node(12);
    root.right.right.left = new Node(50);

    document.write("The sum of leaves is " +leftLeavesSum(root));

    // This code is contributed by unknown2108
</script>

Output

Sum of left leaves is 78

Time Complexity: O(N) where N is the number of nodes in given binary tree.
Auxiliary Space: O(h) where h is the height of given binary tree due to recursion call.

Following is Another Method to solve the above problem. This solution passes in a sum variable as an accumulator. When a left leaf is encountered, the leaf’s data is added to sum. Time complexity of this method is also O(n). Thanks to Xin Tong (geeksforgeeks userid trent.tong) for suggesting this method.

C++

// A C++ program to find sum of all left leaves
#include <bits/stdc++.h>
using namespace std;

/* A binary tree Node has key, pointer to left and right
   children */
struct Node
{
    int key;
    struct Node* left, *right;
};

/* Helper function that allocates a new node with the
   given data and NULL left and right pointer. */
Node *newNode(char k)
{
    Node *node = new Node;
    node->key = k;
    node->right = node->left = NULL;
    return node;
}

/* Pass in a sum variable as an accumulator */
void leftLeavesSumRec(Node *root, bool isleft, int *sum)
{
    if (!root) return;

    // Check whether this node is a leaf node and is left.
    if (!root->left && !root->right && isleft)
        *sum += root->key;

    // Pass 1 for left and 0 for right
    leftLeavesSumRec(root->left,  1, sum);
    leftLeavesSumRec(root->right, 0, sum);
}

// A wrapper over above recursive function
int leftLeavesSum(Node *root)
{
    int sum = 0; //Initialize result

    // use the above recursive function to evaluate sum
    leftLeavesSumRec(root, 0, &sum);

    return sum;
}

/* Driver program to test above functions*/
int main()
{
    // Let us construct the Binary Tree shown in the
    // above figure
    int sum = 0;
    struct Node *root         = newNode(20);
    root->left                = newNode(9);
    root->right               = newNode(49);
    root->right->left         = newNode(23);
    root->right->right        = newNode(52);
    root->right->right->left  = newNode(50);
    root->left->left          = newNode(5);
    root->left->right         = newNode(12);
    root->left->right->right  = newNode(12);

    cout << "Sum of left leaves is "
      << leftLeavesSum(root) << endl;
    return 0;
}

Java

// Java program to find sum of all left leaves
class Node
{
    int data;
    Node left, right;

    Node(int item) {
        data = item;
        left = right = null;
    }
}

// Passing sum as accumulator and implementing pass by reference
// of sum variable
class Sum
{
    int sum = 0;
}

class BinaryTree
{
    Node root;

    /* Pass in a sum variable as an accumulator */
    void leftLeavesSumRec(Node node, boolean isleft, Sum summ)
    {
        if (node == null)
            return;

        // Check whether this node is a leaf node and is left.
        if (node.left == null && node.right == null && isleft)
            summ.sum = summ.sum + node.data;

        // Pass true for left and false for right
        leftLeavesSumRec(node.left, true, summ);
        leftLeavesSumRec(node.right, false, summ);
    }

    // A wrapper over above recursive function
    int leftLeavesSum(Node node)
    {
        Sum suum = new Sum();

        // use the above recursive function to evaluate sum
        leftLeavesSumRec(node, false, suum);

        return suum.sum;
    }

    // Driver program
    public static void main(String args[])
    {
        BinaryTree tree = new BinaryTree();
        tree.root = new Node(20);
        tree.root.left = new Node(9);
        tree.root.right = new Node(49);
        tree.root.left.right = new Node(12);
        tree.root.left.left = new Node(5);
        tree.root.right.left = new Node(23);
        tree.root.right.right = new Node(52);
        tree.root.left.right.right = new Node(12);
        tree.root.right.right.left = new Node(50);

        System.out.println("The sum of leaves is " +
                                    tree.leftLeavesSum(tree.root));
    }
}

// This code is contributed by Mayank Jaiswal

Python3

# Python program to find sum of all left leaves

# A binary tree node
class Node:

    # A constructor to create a new Node
    def __init__(self, key):
        self.key = key
        self.left = None
        self.right = None

def leftLeavesSumRec(root, isLeft, summ):
    if root is None:
        return

    # Check whether this node is a leaf node and is left
    if root.left is None and root.right is None and isLeft == True:
        summ[0] += root.key

    # Pass 1 for left and 0 for right
    leftLeavesSumRec(root.left, 1, summ)
    leftLeavesSumRec(root.right, 0, summ)


# A wrapper over above recursive function
def leftLeavesSum(root):
    summ = [0] # initialize result

    # Use the above recursive function to evaluate sum
    leftLeavesSumRec(root, 0, summ)

    return summ[0]

# Driver program to test above function

# Let us construct the Binary Tree shown in the
# above figure
root = Node(20);
root.left= Node(9);
root.right   = Node(49);
root.right.left = Node(23);
root.right.right= Node(52);
root.right.right.left  = Node(50);
root.left.left  = Node(5);
root.left.right = Node(12);
root.left.right.right  = Node(12);

print ("Sum of left leaves is", leftLeavesSum(root))

# This code is contributed by Nikhil Kumar Singh(nickzuck_007)

C#

using System;

// C# program to find sum of all left leaves
public class Node
{
    public int data;
    public Node left, right;

    public Node(int item)
    {
        data = item;
        left = right = null;
    }
}

// Passing sum as accumulator and implementing pass by reference
// of sum variable
public class Sum
{
    public int sum = 0;
}

public class BinaryTree
{
    public Node root;

    /* Pass in a sum variable as an accumulator */
    public virtual void leftLeavesSumRec(Node node, bool isleft, Sum summ)
    {
        if (node == null)
        {
            return;
        }

        // Check whether this node is a leaf node and is left.
        if (node.left == null && node.right == null && isleft)
        {
            summ.sum = summ.sum + node.data;
        }

        // Pass true for left and false for right
        leftLeavesSumRec(node.left, true, summ);
        leftLeavesSumRec(node.right, false, summ);
    }

    // A wrapper over above recursive function
    public virtual int leftLeavesSum(Node node)
    {
        Sum suum = new Sum();

        // use the above recursive function to evaluate sum
        leftLeavesSumRec(node, false, suum);

        return suum.sum;
    }

    // Driver program
    public static void Main(string[] args)
    {
        BinaryTree tree = new BinaryTree();
        tree.root = new Node(20);
        tree.root.left = new Node(9);
        tree.root.right = new Node(49);
        tree.root.left.right = new Node(12);
        tree.root.left.left = new Node(5);
        tree.root.right.left = new Node(23);
        tree.root.right.right = new Node(52);
        tree.root.left.right.right = new Node(12);
        tree.root.right.right.left = new Node(50);

        Console.WriteLine("The sum of leaves is " + tree.leftLeavesSum(tree.root));
    }
}

  // This code is contributed by Shrikant13

Javascript

<script>
// javascript program to find sum of all left leaves
class Node {
    constructor(item) {
        this.data = item;
        this.left = this.right = null;
    }
}

// Passing sum as accumulator and implementing pass by reference
// of sum variable
class Sum {
constructor(){
    this.sum = 0;
    }
}


    var root;

    /* Pass in a sum variable as an accumulator */
    function leftLeavesSumRec( node,  isleft,  summ) {
        if (node == null)
            return;

        // Check whether this node is a leaf node and is left.
        if (node.left == null && node.right == null && isleft)
            summ.sum = summ.sum + node.data;

        // Pass true for left and false for right
        leftLeavesSumRec(node.left, true, summ);
        leftLeavesSumRec(node.right, false, summ);
    }

    // A wrapper over above recursive function
    function leftLeavesSum( node) {
         suum = new Sum();

        // use the above recursive function to evaluate sum
        leftLeavesSumRec(node, false, suum);

        return suum.sum;
    }

    // Driver program


        root = new Node(20);
        root.left = new Node(9);
        root.right = new Node(49);
        root.left.right = new Node(12);
        root.left.left = new Node(5);
        root.right.left = new Node(23);
        root.right.right = new Node(52);
        root.left.right.right = new Node(12);
        root.right.right.left = new Node(50);

        document.write("The sum of leaves is " + leftLeavesSum(root));

// This code contributed by gauravrajput1
</script>

Output

Sum of left leaves is 78

Time Complexity: O(N) where N is the number of nodes in given binary tree.
Auxiliary Space: O(h) where h is the height of given binary tree due to recursion call.

Following is Another Method to solve the above problem. We can pass bool as parameter in the function to check if it is a left or right node. Time complexity of this method is also O(n). 

C++

#include <bits/stdc++.h>
using namespace std;

struct Node {
    int key;
    Node *left, *right;
};

Node* create(int k)
{
    Node* newnode = new Node();
    newnode->key = k;
    newnode->left = NULL;
    newnode->right = NULL;
    return newnode;
}

int sumAllLeftLeaves(Node* node, bool isleft)
{
    // base case
    if (!node)
        return 0;
    // check whether this node is a leaf node and is left.
    if (!node->left && !node->right && isleft)
        return node->key;

    // recursive case
    return sumAllLeftLeaves(node->left, true)
           + sumAllLeftLeaves(node->right, false);
}

int main()
{
    int sum = 0;
    Node* root = create(20);
    root->left = create(9);
    root->right = create(49);
    root->right->left = create(23);
    root->right->right = create(52);
    root->right->right->left = create(50);
    root->left->left = create(5);
    root->left->right = create(12);
    root->left->right->right = create(12);

    cout << "Sum of left leaves is: "
         << sumAllLeftLeaves(root, false);

    return 0;
}

// This code is contributed by Modem Upendra

C

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

struct Node {
    int data;
    struct Node* left;
    struct Node* right;
};

typedef struct Node str_node;

str_node* create(int item);
int sumAllLeaftLeaves(str_node* node, bool isLeft);

int main(void)
{
    int d = 0;
    str_node* root = create(20);
    root->left = create(9);
    root->right = create(49);
    root->right->left = create(23);
    root->right->right = create(52);
    root->right->right->left = create(50);
    root->left->left = create(5);
    root->left->right = create(12);
    root->left->right->right = create(12);

    printf("\nSum of left leaves is: %d ",
           sumAllLeaftLeaves(root, false));

    return 0;
}

str_node* create(int item)
{
    str_node* newnode = (str_node*)malloc(sizeof(str_node));
    newnode->data = item;
    newnode->left = NULL;
    newnode->right = NULL;
    return newnode;
}

int sumAllLeaftLeaves(str_node* node, bool isLeft)
{
    // base case:
    if (node == NULL)
        return 0;
    // check whether this node is a leaf node and is left.
    if (node->left == NULL && node->right == NULL && isLeft)
        return node->data;

    // recursive case
    return sumAllLeaftLeaves(node->left, true)
           + sumAllLeaftLeaves(node->right, false);
}

Java

class GFG{
  static class Node {
    int data;
    Node left;
    Node right;
  };

  static  Node str_node;

  static Node create(int item)
  {
    Node newnode = new Node();
    newnode.data = item;
    newnode.left = null;
    newnode.right = null;
    return newnode;
  }

  static int sumAllLeaftLeaves(Node node, boolean isLeft)
  {
    // base case:
    if (node == null)
      return 0;
    // check whether this node is a leaf node and is left.
    if (node.left == null && node.right == null && isLeft)
      return node.data;

    // recursive case
    return sumAllLeaftLeaves(node.left, true)
      + sumAllLeaftLeaves(node.right, false);
  }
  public static void main(String[] args)
  {
    int d = 0;
    Node root = create(20);
    root.left = create(9);
    root.right = create(49);
    root.right.left = create(23);
    root.right.right = create(52);
    root.right.right.left = create(50);
    root.left.left = create(5);
    root.left.right = create(12);
    root.left.right.right = create(12);

    System.out.printf("\nSum of left leaves is: %d ",
                      sumAllLeaftLeaves(root, false));

  }
}

// This code is contributed by umadevi9616

Python3

# Python code for the above approach
class Node:
    def __init__(self, k):
        self.data = k
        self.left = None
        self.right = None

def sumAllLeftLeaves(node, isleft):
    # base case
    if node is None:
        return 0

    # check whether this node is a leaf node and is left.
    if node.left is None and node.right is None and isleft:
        return node.data

    # recursive case
    return sumAllLeftLeaves(node.left, True) + sumAllLeftLeaves(node.right, False)

# Driver program
root = Node(20)
root.left = Node(9)
root.right = Node(49)
root.left.right = Node(12)
root.left.left = Node(5)
root.right.left = Node(23)
root.right.right = Node(52)
root.left.right.right = Node(12)
root.right.right.left = Node(50)

print("The sum of leaves is " + str(sumAllLeftLeaves(root, False)))

# This code is contributed by Potta Lokesh

C#

// C# implementation

using System;

public class GFG {

    public class Node {
        public int data;
        public Node left;
        public Node right;
    }

    static Node str_node;

    static Node create(int item)
    {
        Node newnode = new Node();
        newnode.data = item;
        newnode.left = null;
        newnode.right = null;
        return newnode;
    }

    static int sumAllLeaftLeaves(Node node, bool isLeft)
    {
        // base case:
        if (node == null)
            return 0;
        // check whether this node is a leaf node and is
        // left.
        if (node.left == null && node.right == null
            && isLeft)
            return node.data;

        // recursive case
        return sumAllLeaftLeaves(node.left, true)
            + sumAllLeaftLeaves(node.right, false);
    }

    static public void Main()
    {

        // Code
        int d = 0;
        Node root = create(20);
        root.left = create(9);
        root.right = create(49);
        root.right.left = create(23);
        root.right.right = create(52);
        root.right.right.left = create(50);
        root.left.left = create(5);
        root.left.right = create(12);
        root.left.right.right = create(12);

        Console.WriteLine("\nSum of left leaves is: "
                          + sumAllLeaftLeaves(root, false));
    }
}

// This code is contributed by lokesh

Javascript

class Node
    {
        constructor(k)
        {
            this.data = k;
            this.left = null;
            this.right = null;
        }

    }
function sumAllLeftLeaves(node, isleft)
{
    // base case
    if (node == null)
        return 0;

    // check whether this node is a leaf node and is left.
    if (node.left==null && node.right==null && isleft==true)
        return node.data;

    // recursive case
    return sumAllLeftLeaves(node.left, true)
           + sumAllLeftLeaves(node.right, false);
}


       // Driver program
    root = new Node(20);
    root.left = new Node(9);
    root.right = new Node(49)a;
    root.left.right = new Node(12);
    root.left.left = new Node(5);
    root.right.left = new Node(23);
    root.right.right = new Node(52);
    root.left.right.right = new Node(12);
    root.right.right.left = new Node(50);

    document.write("The sum of leaves is " +sumAllLeftLeaves(root,false));

    // This code is contributed by garg28harsh.

Output

Sum of left leaves is: 78 

Iterative Approach :

This is the Iterative Way to find the sum of the left leaves. 
Idea is to perform Depth-First Traversal on the tree (either Inorder, Preorder or Postorder) using a stack and checking if the Left Child is a Leaf node. If it is, then add the nodes value to the sum variable 

C++

// C++ program to find sum of all left leaves
#include<bits/stdc++.h>
using namespace std;

// A binary tree node
class Node
{
    public:
    int key;
    Node* left, *right;

    // A constructor to create a new Node
    Node(int key_)
    {
        key = key_;
        left = NULL;
        right = NULL;
    }
};

// Return the sum of left leaf nodes
int sumOfLeftLeaves(Node* root)
{
    if(root == NULL)
        return 0;

    // Using a stack_ for Depth-First
    // Traversal of the tree
    stack<Node*> stack_;
    stack_.push(root);

    // sum holds the sum of all the left leaves
    int sum = 0;

    while(stack_.size() > 0)
    {
        Node* currentNode = stack_.top();
        stack_.pop();

        if (currentNode->left != NULL)
        {
            stack_.push(currentNode->left);

            // Check if currentNode's left
            // child is a leaf node
            if(currentNode->left->left == NULL &&
               currentNode->left->right == NULL)
            {
                // if currentNode is a leaf,
                // add its data to the sum
                sum = sum + currentNode->left->key ;
            }
        }
        if (currentNode->right != NULL)
            stack_.push(currentNode->right);
    }

    return sum;
}

// Driver Code
int main()
{
    Node *root = new Node(20);
    root->left= new Node(9);
    root->right = new Node(49);
    root->right->left = new Node(23);
    root->right->right= new Node(52);
    root->right->right->left = new Node(50);
    root->left->left = new Node(5);
    root->left->right = new Node(12);
    root->left->right->right = new Node(12);

    cout << "Sum of left leaves is "
      << sumOfLeftLeaves(root) << endl;
    return 0;
}

// This code is contributed by Arnab Kundu

Java

// Java program to find sum of all left leaves
import java.util.*;
class GFG
{

// A binary tree node
static class Node
{
    int key;
    Node left, right;

    // A constructor to create a new Node
    Node(int key_)
    {
        this.key = key_;
        this.left = null;
        this.right = null;
    }
};

// Return the sum of left leaf nodes
static int sumOfLeftLeaves(Node root)
{
    if(root == null)
    return 0;

    // Using a stack_ for Depth-First
    // Traversal of the tree
    Stack<Node> stack_ = new Stack<>();
    stack_.push(root);

    // sum holds the sum of all the left leaves
    int sum = 0;

    while(stack_.size() > 0)
    {
        Node currentNode = stack_.peek();
        stack_.pop();

        if (currentNode.left != null)
        {
            stack_.add(currentNode.left);

            // Check if currentNode's left
            // child is a leaf node
            if(currentNode.left.left == null &&
               currentNode.left.right == null)
            {
                // if currentNode is a leaf,
                // add its data to the sum
                sum = sum + currentNode.left.key ;
            }
        }
        if (currentNode.right != null)
            stack_.add(currentNode.right);
    }
    return sum;
}

// Driver Code
public static void main(String[] args)
{
    Node root = new Node(20);
    root.left= new Node(9);
    root.right = new Node(49);
    root.right.left = new Node(23);
    root.right.right= new Node(52);
    root.right.right.left = new Node(50);
    root.left.left = new Node(5);
    root.left.right = new Node(12);
    root.left.right.right = new Node(12);

    System.out.print("Sum of left leaves is "
      + sumOfLeftLeaves(root) +"\n");
}
}

// This code is contributed by aashish1995

Python3

# Python3 program to find sum of all left leaves

# A binary tree node
class Node:

    # A constructor to create a new Node
    def __init__(self, key):
        self.data = key
        self.left = None
        self.right = None


# Return the sum of left leaf nodes
def sumOfLeftLeaves(root):
    if(root is None):
        return

    # Using a stack for Depth-First Traversal of the tree
    stack = []
    stack.append(root)

    # sum holds the sum of all the left leaves
    sum = 0

    while len(stack) > 0:
        currentNode = stack.pop()
        if currentNode.left is not None:
            stack.append(currentNode.left)

            # Check if currentNode's left child is a leaf node
            if currentNode.left.left is None and currentNode.left.right is None:

                # if currentNode is a leaf, add its data to the sum
                sum = sum + currentNode.left.data

        if currentNode.right is not None:
            stack.append(currentNode.right)
    return sum

# Driver Code
root = Node(20);
root.left= Node(9);
root.right   = Node(49);
root.right.left = Node(23);
root.right.right= Node(52);
root.right.right.left  = Node(50);
root.left.left  = Node(5);
root.left.right = Node(12);
root.left.right.right  = Node(12);

print('Sum of left leaves is {}'.format(sumOfLeftLeaves(root)))

C#

// C# program to find sum of all left leaves
using System;
using System.Collections.Generic;
class GFG
{

  // A binary tree node
  public
    class Node
    {
      public
        int key;
      public
        Node left, right;

      // A constructor to create a new Node
      public
        Node(int key_)
      {
        this.key = key_;
        this.left = null;
        this.right = null;
      }
    };

  // Return the sum of left leaf nodes
  static int sumOfLeftLeaves(Node root)
  {
    if(root == null)
      return 0;

    // Using a stack_ for Depth-First
    // Traversal of the tree
    Stack<Node> stack_ = new Stack<Node>();
    stack_.Push(root);

    // sum holds the sum of all the left leaves
    int sum = 0;
    while(stack_.Count > 0)
    {
      Node currentNode = stack_.Peek();
      stack_.Pop();
      if (currentNode.left != null)
      {
        stack_.Push(currentNode.left);

        // Check if currentNode's left
        // child is a leaf node
        if(currentNode.left.left == null &&
           currentNode.left.right == null)
        {

          // if currentNode is a leaf,
          // add its data to the sum
          sum = sum + currentNode.left.key ;
        }
      }
      if (currentNode.right != null)
        stack_.Push(currentNode.right);
    }
    return sum;
  }

  // Driver Code
  public static void Main(String[] args)
  {
    Node root = new Node(20);
    root.left= new Node(9);
    root.right = new Node(49);
    root.right.left = new Node(23);
    root.right.right= new Node(52);
    root.right.right.left = new Node(50);
    root.left.left = new Node(5);
    root.left.right = new Node(12);
    root.left.right.right = new Node(12);

    Console.Write("Sum of left leaves is "
                  + sumOfLeftLeaves(root) +"\n");
  }
}

// This code is contributed by Rajput-Ji

Javascript

<script>


// JavaScript program to find sum of all left leaves
// A binary tree node
class Node
{

  // A constructor to create a new Node
  constructor(key_)
  {
    this.key = key_;
    this.left = null;
    this.right = null;
  }
};
// Return the sum of left leaf nodes
function sumOfLeftLeaves(root)
{
  if(root == null)
    return 0;
  // Using a stack_ for Depth-First
  // Traversal of the tree
  var stack_ = [];
  stack_.push(root);
  // sum holds the sum of all the left leaves
  var sum = 0;
  while(stack_.length > 0)
  {
    var currentNode = stack_[stack_.length-1];
    stack_.pop();
    if (currentNode.left != null)
    {
      stack_.push(currentNode.left);
      // Check if currentNode's left
      // child is a leaf node
      if(currentNode.left.left == null &&
         currentNode.left.right == null)
      {
        // if currentNode is a leaf,
        // add its data to the sum
        sum = sum + currentNode.left.key ;
      }
    }
    if (currentNode.right != null)
      stack_.push(currentNode.right);
  }
  return sum;
}

// Driver Code
var root = new Node(20);
root.left= new Node(9);
root.right = new Node(49);
root.right.left = new Node(23);
root.right.right= new Node(52);
root.right.right.left = new Node(50);
root.left.left = new Node(5);
root.left.right = new Node(12);
root.left.right.right = new Node(12);
document.write("Sum of left leaves is "
              + sumOfLeftLeaves(root) +"<br>");


</script>

Output

Sum of left leaves is 78

Time Complexity: O(N) where N is the number of nodes in given binary tree.
Auxiliary Space: O(h) where h is the height of given binary tree.

Thanks to Shubham Tambere for suggesting this approach.

BFS Approach: We can do BFS traversal and keep a separate variable for denoting if it is a left child or right child of a node. As soon as we encounter a leaf, we check if it is a left child of its parent or right child of its parent. If it is a left child, we add its value in the sum.

Below is the implementation of the above approach:

C++

// C++ program to find sum of all left leaves
#include <bits/stdc++.h>
using namespace std;

// A binary tree node
class Node {
public:
    int key;
    Node *left, *right;

    // constructor to create a new Node
    Node(int key_)
    {
        key = key_;
        left = NULL;
        right = NULL;
    }
};

// Return the sum of left leaf nodes
int sumOfLeftLeaves(Node* root)
{
    if (root == NULL)
        return 0;
    // A queue of pairs to do bfs traversal
    // and keep track if the node is a left
    // or right child if boolean value
    // is true then it is a left child.
    queue<pair<Node*, bool> > q;
    q.push({ root, 0 });
    int sum = 0;
    // do bfs traversal
    while (!q.empty()) {
        Node* temp = q.front().first;
        bool is_left_child =
                   q.front().second;
        q.pop();
        // if temp is a leaf node and
        // left child of its parent
        if (!temp->left && !temp->right &&
                            is_left_child)
            sum = sum + temp->key;
        // if it is not leaf then
        // push its children nodes
        // into queue
        if (temp->left) {
            // boolean value is true
            // here because it is left
            // child of its parent
            q.push({ temp->left, 1 });
        }
        if (temp->right) {
            // boolean value is false
            // here because it is
            // right child of its parent
            q.push({ temp->right, 0 });
        }
    }
    return sum;
}

// Driver Code
int main()
{
    Node* root = new Node(20);
    root->left = new Node(9);
    root->right = new Node(49);
    root->right->left = new Node(23);
    root->right->right = new Node(52);
    root->right->right->left = new Node(50);
    root->left->left = new Node(5);
    root->left->right = new Node(12);
    root->left->right->right = new Node(12);

    cout << "Sum of left leaves is "
         << sumOfLeftLeaves(root) << endl;
    return 0;
}

Java

// Java program to find sum of all left leaves
import java.util.*;
class GFG
{

// A binary tree node
static class Node
{
    int key;
    Node left, right;

    // constructor to create a new Node
    Node(int key_)
    {
        key = key_;
        left = null;
        right = null;
    }
};
static class pair
{
    Node first;
    boolean second;
    public pair(Node first, boolean second)
    {
        this.first = first;
        this.second = second;
    }
}

// Return the sum of left leaf nodes
static int sumOfLeftLeaves(Node root)
{
    if (root == null)
    return 0;

    // A queue of pairs to do bfs traversal
    // and keep track if the node is a left
    // or right child if boolean value
    // is true then it is a left child.
    Queue<pair > q = new LinkedList<>();
    q.add(new pair( root, false ));
    int sum = 0;

    // do bfs traversal
    while (!q.isEmpty())
    {
        Node temp = q.peek().first;
        boolean is_left_child =
                   q.peek().second;
        q.remove();

        // if temp is a leaf node and
        // left child of its parent
        if (is_left_child)
            sum = sum + temp.key;
        if(temp.left != null && temp.right != null && is_left_child)
            sum = sum-temp.key;

        // if it is not leaf then
        // push its children nodes
        // into queue
        if (temp.left != null)
        {

            // boolean value is true
            // here because it is left
            // child of its parent
            q.add(new pair( temp.left, true));
        }
        if (temp.right != null)
        {

            // boolean value is false
            // here because it is
            // right child of its parent
            q.add(new pair( temp.right, false));
        }
    }
    return sum;
}

// Driver Code
public static void main(String[] args)
{
    Node root = new Node(20);
    root.left = new Node(9);
    root.right = new Node(49);
    root.right.left = new Node(23);
    root.right.right = new Node(52);
    root.right.right.left = new Node(50);
    root.left.left = new Node(5);
    root.left.right = new Node(12);
    root.left.right.right = new Node(12);

    System.out.print("Sum of left leaves is "
         + sumOfLeftLeaves(root) +"\n");
}
}

// This code is contributed by gauravrajput1.

Python3

# Python3 program to find sum of
# all left leaves
from collections import deque

# A binary tree node
class Node:

    def __init__(self, x):

        self.key = x
        self.left = None
        self.right = None

# Return the sum of left leaf nodes
def sumOfLeftLeaves(root):

    if (root == None):
        return 0

    # A queue of pairs to do bfs traversal
    # and keep track if the node is a left
    # or right child if boolean value
    # is true then it is a left child.
    q = deque()
    q.append([root, 0])
    sum = 0

    # Do bfs traversal
    while (len(q) > 0):
        temp = q[0][0]
        is_left_child = q[0][1]
        q.popleft()

        # If temp is a leaf node and
        # left child of its parent
        if (not temp.left and
            not temp.right and
            is_left_child):
            sum = sum + temp.key

        # If it is not leaf then
        # push its children nodes
        # into queue
        if (temp.left):

            # Boolean value is true
            # here because it is left
            # child of its parent
            q.append([temp.left, 1])

        if (temp.right):

            # Boolean value is false
            # here because it is
            # right child of its parent
            q.append([temp.right, 0])

    return sum

# Driver Code
if __name__ == '__main__':

    root = Node(20)
    root.left = Node(9)
    root.right = Node(49)
    root.right.left = Node(23)
    root.right.right = Node(52)
    root.right.right.left = Node(50)
    root.left.left = Node(5)
    root.left.right = Node(12)
    root.left.right.right = Node(12)

    print("Sum of left leaves is",
          sumOfLeftLeaves(root))

# This code is contributed by mohit kumar 29

C#

// C# program to find sum of all left leaves
using System;
using System.Collections.Generic;
public class GFG
{

  // A binary tree node
  public

    class Node
    {
      public int key;
      public

        Node left,
      right;

      // constructor to create a new Node
      public

        Node(int key_)
      {
        key = key_;
        left = null;
        right = null;
      }
    };
  public

    class pair {
      public

        Node first;
      public

        bool second;
      public pair(Node first, bool second)
      {
        this.first = first;
        this.second = second;
      }
    }

  // Return the sum of left leaf nodes
  static int sumOfLeftLeaves(Node root)
  {
    if (root == null)
      return 0;

    // A queue of pairs to do bfs traversal
    // and keep track if the node is a left
    // or right child if bool value
    // is true then it is a left child.
    Queue<pair> q = new Queue<pair>();
    q.Enqueue(new pair(root, false));
    int sum = 0;

    // do bfs traversal
    while (q.Count != 0)
    {
      Node temp = q.Peek().first;
      bool is_left_child = q.Peek().second;
      q.Dequeue();

      // if temp is a leaf node and
      // left child of its parent
      if (is_left_child)
        sum = sum + temp.key;
      if (temp.left != null && temp.right != null
          && is_left_child)
        sum = sum - temp.key;

      // if it is not leaf then
      // push its children nodes
      // into queue
      if (temp.left != null)
      {

        // bool value is true
        // here because it is left
        // child of its parent
        q.Enqueue(new pair(temp.left, true));
      }
      if (temp.right != null)
      {

        // bool value is false
        // here because it is
        // right child of its parent
        q.Enqueue(new pair(temp.right, false));
      }
    }
    return sum;
  }

  // Driver Code
  public static void Main(String[] args)
  {
    Node root = new Node(20);
    root.left = new Node(9);
    root.right = new Node(49);
    root.right.left = new Node(23);
    root.right.right = new Node(52);
    root.right.right.left = new Node(50);
    root.left.left = new Node(5);
    root.left.right = new Node(12);
    root.left.right.right = new Node(12);

    Console.Write("Sum of left leaves is "
                  + sumOfLeftLeaves(root) + "\n");
  }
}

// This code is contributed by gauravrajput1

Javascript

<script>

    // JavaScript program to find sum of all left leaves

    class Node
    {
        constructor(key_) {
           this.left = null;
           this.right = null;
           this.key = key_;
        }
    }

    // Return the sum of left leaf nodes
    function sumOfLeftLeaves(root)
    {
        if (root == null)
            return 0;

        // A queue of pairs to do bfs traversal
        // and keep track if the node is a left
        // or right child if boolean value
        // is true then it is a left child.
        let q = [];
        q.push([root, false ]);
        let sum = 0;

        // do bfs traversal
        while (q.length > 0)
        {
            let temp = q[0][0];
            let is_left_child =
                       q[0][1];
            q.shift();

            // if temp is a leaf node and
            // left child of its parent
            if (is_left_child)
                sum = sum + temp.key;
            if(temp.left != null &&
            temp.right != null && is_left_child)
                sum = sum-temp.key;

            // if it is not leaf then
            // push its children nodes
            // into queue
            if (temp.left != null)
            {

                // boolean value is true
                // here because it is left
                // child of its parent
                q.push([temp.left, true]);
            }
            if (temp.right != null)
            {

                // boolean value is false
                // here because it is
                // right child of its parent
                q.push([temp.right, false]);
            }
        }
        return sum;
    }

    let root = new Node(20);
    root.left = new Node(9);
    root.right = new Node(49);
    root.right.left = new Node(23);
    root.right.right = new Node(52);
    root.right.right.left = new Node(50);
    root.left.left = new Node(5);
    root.left.right = new Node(12);
    root.left.right.right = new Node(12);

    document.write("Sum of left leaves is "
         + sumOfLeftLeaves(root) +"</br>");

</script>

Output

Sum of left leaves is 78

Time Complexity: O(N)
Auxiliary Space: O(N)