Find sum of all right leaves in a given Binary Tree

Last Updated : 1 Nov, 2024

Given a Binary Tree, the task is to find the sum of all right leaf nodes in it.

Examples :

Example1: Sum of all the right leaf nodes in the below tree is 2 + 5 + 7 = 15

Example2: Sum of all the right leaf nodes in the below tree is 5 + 8 = 13

Try It Yourself

Table of Content

[Expected Approach - 1] Using Recursion - O(n) Time and O(h) Space
[Alternate Approach] Using Recursion - O(n) Time and O(h) Space
[Expected Approach - 2] Using Iterative Method - O(n) Time and O(n) Space

[Expected Approach - 1] Using Recursion - O(n) Time and O(h) Space

The idea is to use recursion to traverse the tree starting from the root and check if the node is the leaf node or not. If the node is the right leaf than add data of right leaf to sum variable.

Below is the implementation for the above approach:

C++

// C++ program to find sum of all right 
// leaf nodes in a binary tree
#include <iostream>
using namespace std;

class Node {
public:
    int data;
    Node *left, *right;

    Node(int value) {
        data = value;
        left = right = nullptr;
    }
};

// Recursive function to find the sum of 
// right leaf nodes
void rightLeafSum(Node* root, int &sum) {
    if (!root)
        return;

    // Check if the right child of root is a leaf node
    if (root->right && !root->right->left
                          && !root->right->right) {
      
        sum += root->right->data;
    }

    // Recur for the left and right children
    rightLeafSum(root->left, sum);
    rightLeafSum(root->right, sum);
}

int main() {
  
    // Representation of given the binary tree
    //     1
    //    / \
    //   2   3
    //    \   \
    //     5   8
    Node* root = new Node(1);
    root->left = new Node(2);
    root->right = new Node(3);
    root->left->right = new Node(5);
    root->right->right = new Node(8);

    int sum = 0;
    rightLeafSum(root, sum);
    cout << sum << endl;  

    return 0;
}

Java

// Java program to find sum of all right 
// leaf nodes in a binary tree
import java.util.*;

class Node {
    int data;
    Node left, right;

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

// Recursive function to find the sum of 
// right leaf nodes
class GfG {
  
    static void rightLeafSum(Node root, int[] sum) {
        if (root == null)
            return;

        // Check if the right child of root 
      	// is a leaf node
        if (root.right != null && root.right.left == null
                            && root.right.right == null) {
            
            sum[0] += root.right.data;
        }

        // Recur for the left and right children
        rightLeafSum(root.left, sum);
        rightLeafSum(root.right, sum);
    }

    public static void main(String[] args) {
      
        // Representation of given the binary tree
        //     1
        //    / \
        //   2   3
        //    \   \
        //     5   8
        Node root = new Node(1);
        root.left = new Node(2);
        root.right = new Node(3);
        root.left.right = new Node(5);
        root.right.right = new Node(8);

        int[] sum = {0};
        rightLeafSum(root, sum);
        System.out.println(sum[0]);
    }
}

Python

# Python program to find sum of all right 
# leaf nodes in a binary tree
class Node:
    def __init__(self, value):
        self.data = value
        self.left = None
        self.right = None

# Recursive function to find the sum of 
# right leaf nodes
def rightLeafSum(root, sum_ref):
    if not root:
        return

    # Check if the right child of root
    # is a leaf node
    if root.right and not root.right.left \
                   and not root.right.right:
      
        sum_ref[0] += root.right.data

    # Recur for the left and right children
    rightLeafSum(root.left, sum_ref)
    rightLeafSum(root.right, sum_ref)
    
if __name__=='__main__':
  
    # Representation of given the binary tree
    #     1
    #    / \
    #   2   3
    #    \   \
    #     5   8
    root = Node(1)
    root.left = Node(2)
    root.right = Node(3)
    root.left.right = Node(5)
    root.right.right = Node(8)

    sum_ref = [0]
    rightLeafSum(root, sum_ref)
    print(sum_ref[0])

C#

// C# program to find sum of all right 
// leaf nodes in a binary tree
using System;

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

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

// Recursive function to find the sum of 
// right leaf nodes
class GfG {
    static void RightLeafSum(Node root, ref int sum) {
        if (root == null)
            return;

        // Check if the right child of root 
      	// is a leaf node
        if (root.right != null && root.right.left == null
                                && root.right.right == null) {
            
            sum += root.right.data;
        }

        // Recur for the left and right children
        RightLeafSum(root.left, ref sum);
        RightLeafSum(root.right, ref sum);
    }

    static void Main(string[] args) {
      
        // Representation of given the binary tree
        //     1
        //    / \
        //   2   3
        //    \   \
        //     5   8
        Node root = new Node(1);
        root.left = new Node(2);
        root.right = new Node(3);
        root.left.right = new Node(5);
        root.right.right = new Node(8);

        int sum = 0;
        RightLeafSum(root, ref sum);
        Console.WriteLine(sum);
    }
}

JavaScript

// JavaScript program to find sum of all right 
// leaf nodes in a binary tree
class Node {
    constructor(value) {
        this.data = value;
        this.left = null;
        this.right = null;
    }
}

// Recursive function to find the sum of 
// right leaf nodes
function rightLeafSum(root, sumRef) {
    if (!root)
        return;

    // Check if the right child of root
    // is a leaf node
    if (root.right && !root.right.left 
                               && !root.right.right) {
                               
        sumRef.sum += root.right.data;
    }

    // Recur for the left and 
    // right children
    rightLeafSum(root.left, sumRef);
    rightLeafSum(root.right, sumRef);
}

// Representation of given the binary tree
//     1
//    / \
//   2   3
//    \   \
//     5   8
let root = new Node(1);
root.left = new Node(2);
root.right = new Node(3);
root.left.right = new Node(5);
root.right.right = new Node(8);

let sumRef = { sum: 0 };
rightLeafSum(root, sumRef);
console.log(sumRef.sum);

Output

[Alternate Approach] Using Recursion - O(n) Time and O(h) Space

Alternative idea to solve the above problem is that we can pass bool as parameter in the function to check if it is a left or right node. For right node we pass it as true, and false for left node.

Below is the implementation for the above approach:

C++

// C++ program to find sum of all right 
// leaf nodes in a binary tree
#include <iostream>
using namespace std;

class Node {
public:
    int data;
    Node *left, *right;

    Node(int value) {
        data = value;
        left = right = nullptr;
    }
};

int rightLeafSum(Node* root, bool isrightleaf) {
  
    // base case
    if (!root)
        return 0;

    // if it is a leaf node and right node, the return
    // root's data.
    if (!root->left && !root->right && isrightleaf)
        return root->data;

    // recur of left subtree and right subtree and do the
    // summation simultaniously.
    return rightLeafSum(root->left, false)
           + rightLeafSum(root->right, true);
}

int main() {
  
    // Representation of given the binary tree
    //     1
    //    / \
    //   2   3
    //    \   \
    //     5   8
    Node* root = new Node(1);
    root->left = new Node(2);
    root->right = new Node(3);
    root->left->right = new Node(5);
    root->right->right = new Node(8);

    bool isrightleaf = 0;
    int sum = rightLeafSum(root, isrightleaf);
    cout << sum << endl;  

    return 0;
}

Java

// Java program to find sum of all right 
// leaf nodes in a binary tree
import java.util.*;

class Node {
    int data;
    Node left, right;

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

class GfG {
    static int rightLeafSum(Node root, 
                            boolean isRightLeaf) {

        // base case
        if (root == null)
            return 0;

        // if it is a leaf node and right node, 
      	// return root's data
        if (root.left == null && root.right == null 
            && isRightLeaf)
            return root.data;

        // recur on left subtree and right subtree 
        // and do the summation simultaneously
        return rightLeafSum(root.left, false)
             + rightLeafSum(root.right, true);
    }

    public static void main(String[] args) {

        // Representation of the given binary tree
        //     1
        //    / \
        //   2   3
        //    \   \
        //     5   8
        Node root = new Node(1);
        root.left = new Node(2);
        root.right = new Node(3);
        root.left.right = new Node(5);
        root.right.right = new Node(8);

        int sum = rightLeafSum(root, false);
        System.out.println(sum);
    }
}

Python

# Python program to find sum of all right 
# leaf nodes in a binary tree
class Node:
    def __init__(self, value):
        self.data = value
        self.left = None
        self.right = None

def rightleafsum(root, isrightleaf):
  
    # base case
    if not root:
        return 0

    # if it is a leaf node and right node, 
    # return root's data
    if not root.left and not root.right\
    and isrightleaf:
        return root.data

    # recur on left subtree and right subtree 
    # and do the summation simultaneously
    return rightleafsum(root.left, False) \
                    + rightleafsum(root.right, True)
  
if __name__=='__main__':
  
    # Representation of the given binary tree
    #     1
    #    / \
    #   2   3
    #    \   \
    #     5   8
    root = Node(1)
    root.left = Node(2)
    root.right = Node(3)
    root.left.right = Node(5)
    root.right.right = Node(8)

    sumResult = rightleafsum(root, False)
    print(sumResult)

C#

// C# program to find sum of all right 
// leaf nodes in a binary tree
using System;

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

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

class GfG {
    static int RightLeafSum(Node root, 
                            bool isRightLeaf) {

        // base case
        if (root == null)
            return 0;

        // if it is a leaf node and right node,
        // return root's data
        if (root.left == null 
            && root.right == null && isRightLeaf)
            return root.data;

        // recur on left subtree and right subtree 
       // and do the summation simultaneously
        return RightLeafSum(root.left, false)
             + RightLeafSum(root.right, true);
    }

    static void Main(string[] args) {

        // Representation of the given binary tree
        //     1
        //    / \
        //   2   3
        //    \   \
        //     5   8
        Node root = new Node(1);
        root.left = new Node(2);
        root.right = new Node(3);
        root.left.right = new Node(5);
        root.right.right = new Node(8);

        int sum = RightLeafSum(root, false);
        Console.WriteLine(sum);
    }
}

JavaScript

// JavaScript program to find sum of all right 
// leaf nodes in a binary tree
class Node {
    constructor(value) {
        this.data = value;
        this.left = null;
        this.right = null;
    }
}

function rightLeafSum(root, isRightLeaf) {

    // base case
    if (!root)
        return 0;

    // if it is a leaf node and right node, 
    // return root's data
    if (!root.left && !root.right && isRightLeaf)
        return root.data;

    // recur on left subtree and right subtree 
    // and do the summation simultaneously
    return rightLeafSum(root.left, false)
         + rightLeafSum(root.right, true);
}

// Representation of the given binary tree
//     1
//    / \
//   2   3
//    \   \
//     5   8
let root = new Node(1);
root.left = new Node(2);
root.right = new Node(3);
root.left.right = new Node(5);
root.right.right = new Node(8);

let sum = rightLeafSum(root, false);
console.log(sum);

Output

[Expected Approach - 2] Using Iterative Method - O(n) Time and O(n) Space

The idea is to traverse the tree in level order manner using queue and whenever we reach the right node check if it is a leaf node. If it is a leaf node then increment the sum.

Below is the implementation for the above approach:

C++

// C++ program to find sum of all right 
// leaf nodes in a binary tree
#include <bits/stdc++.h>
using namespace std;

class Node {
public:
    int data;
    Node *left, *right;

    Node(int value) {
        data = value;
        left = right = nullptr;
    }
};

// Utility function to calculate sum
// of right leaf nodes iteratively
int rightLeafSum(Node* root) {
  
    // Declaring sum to store sum 
  	// of right leaves
    int sum = 0;
    queue<Node*>q;
  
    q.push(root);
    while (!q.empty()) {
        Node* curr = q.front();
        q.pop();
      
        // Check for left node
        if (curr->left) {
            q.push(curr->left);
        }
      
        // Check for right node
        if (curr->right) {

            // Check for right leaf node
            if (curr->right->right == nullptr
                and curr->right->left == nullptr) {
              
                // incrementing sum for found right leaf
                // node
                sum += curr->right->data;
            }
            q.push(curr->right);
        }
    }
    return sum;
}

int main() {
  
    // Representation of given the binary tree
    //     1
    //    / \
    //   2   3
    //    \   \
    //     5   8
    Node* root = new Node(1);
    root->left = new Node(2);
    root->right = new Node(3);
    root->left->right = new Node(5);
    root->right->right = new Node(8);

    int sum = rightLeafSum(root);
    cout << sum << endl;  

    return 0;
}

Java

// Java program to find sum of all right 
// leaf nodes in a binary tree
import java.util.*;

class Node {
    int data;
    Node left, right;

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

class GfG {
  
    // Utility function to calculate sum of right 
    // leaf nodes iteratively
    static int rightLeafSum(Node root) {

        // Declaring sum to store sum of right leaves
        int sum = 0;
        Queue<Node> q = new LinkedList<>();

        q.add(root);
        while (!q.isEmpty()) {
            Node curr = q.poll();

            // Check for left node
            if (curr.left != null) {
                q.add(curr.left);
            }

            // Check for right node
            if (curr.right != null) {

                // Check for right leaf node
                if (curr.right.left == null 
                       && curr.right.right == null) {
                  
                    // incrementing sum for found
                  	// right leaf node
                    sum += curr.right.data;
                }
                q.add(curr.right);
            }
        }
        return sum;
    }

    public static void main(String[] args) {

        // Representation of given the binary tree
        //     1
        //    / \
        //   2   3
        //    \   \
        //     5   8
        Node root = new Node(1);
        root.left = new Node(2);
        root.right = new Node(3);
        root.left.right = new Node(5);
        root.right.right = new Node(8);
      
        int sum = rightLeafSum(root);
        System.out.println(sum);
    }
}

Python

# Python program to find sum of all right 
# leaf nodes in a binary tree
from collections import deque

class Node:
    def __init__(self, value):
        self.data = value
        self.left = None
        self.right = None

# Utility function to calculate sum of 
# right leaf nodes iteratively
def right_leaf_sum(root):
  
    # Declaring sum to store sum of
    # right leaves
    sum = 0
    q = deque([root])

    while q:
        curr = q.popleft()

        # Check for left node
        if curr.left:
            q.append(curr.left)

        # Check for right node
        if curr.right:

            # Check for right leaf node
            if curr.right.left is None \
                      and curr.right.right is None:
              
                # incrementing sum for found
                # right leaf node
                sum += curr.right.data

            q.append(curr.right)

    return sum
  
if __name__=='__main__':
  
    # Representation of given the binary tree
    #     1
    #    / \
    #   2   3
    #    \   \
    #     5   8
    root = Node(1)
    root.left = Node(2)
    root.right = Node(3)
    root.left.right = Node(5)
    root.right.right = Node(8)

    sum_result = right_leaf_sum(root)
    print(sum_result)

C#

// C# program to find sum of all right 
// leaf nodes in a binary tree
using System;
using System.Collections.Generic;

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

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

class GfG {
  
    // Utility function to calculate sum of 
    // right leaf nodes iteratively
    static int RightLeafSum(Node root) {
      
        // Declaring sum to store sum of
      	// right leaves
        int sum = 0;
        Queue<Node> q = new Queue<Node>();
      
        q.Enqueue(root);
        while (q.Count > 0) {
            Node curr = q.Dequeue();
          
            // Check for left node
            if (curr.left != null) {
                q.Enqueue(curr.left);
            }

            // Check for right node
            if (curr.right != null) {

                // Check for right leaf node
                if (curr.right.left == null 
                        && curr.right.right == null) {
                  
                    // incrementing sum for 
                  	// found right leaf node
                    sum += curr.right.data;
                }
                q.Enqueue(curr.right);
            }
        }
        return sum;
    }

    static void Main(string[] args) {

        // Representation of given the binary tree
        //     1
        //    / \
        //   2   3
        //    \   \
        //     5   8
        Node root = new Node(1);
        root.left = new Node(2);
        root.right = new Node(3);
        root.left.right = new Node(5);
        root.right.right = new Node(8);

        int sum = RightLeafSum(root);
        Console.WriteLine(sum);
    }
}

JavaScript

// JavaScript program to find sum of all right 
// leaf nodes in a binary tree
class Node {
    constructor(value) {
        this.data = value;
        this.left = null;
        this.right = null;
    }
}

// Utility function to calculate sum of 
// right leaf nodes iteratively
function rightLeafSum(root) {
  
    // Declaring sum to store sum 
    // of right leaves
    let sum = 0;
    const q = [root];

    while (q.length > 0) {
        const curr = q.shift();

        // Check for left node
        if (curr.left) {
            q.push(curr.left);
        }

        // Check for right node
        if (curr.right) {

            // Check for right leaf node
            if (!curr.right.left && !curr.right.right) {
            
                // incrementing sum for found 
                // right leaf node
                sum += curr.right.data;
            }
            q.push(curr.right);
        }
    }
    return sum;
}

// Representation of given the binary tree
//     1
//    / \
//   2   3
//    \   \
//     5   8
const root = new Node(1);
root.left = new Node(2);
root.right = new Node(3);
root.left.right = new Node(5);
root.right.right = new Node(8);

const sum = rightLeafSum(root);
console.log(sum);

Output

Related article:

Find sum of all left leaves in a given Binary Tree

Comment

Article Tags:

Explore