Find sum of all right leaves in a given Binary Tree - GeeksforGeeks

27 Sep, 2021
Given a Binary Tree, find sum of all right leaves in it. Similar article: Find sum of all left leaves in a given Binary TreeExample : 
Input : 
         1
        /  \
       2    3
     /  \     \
    4    5     8 
     \        /  \
      2       6   7

Output :
sum = 2 + 5 + 7 = 14
Method 1: Recursive Method
The idea is 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.Following is the implementation for the same.  
C++
Java
Python3
C#
Javascript
// CPP program to find total sum// of right leaf nodes#include <bits/stdc++.h>using namespace std; // struct node of binary treestruct Node{    int data;    Node *left, *right;}; // return new nodeNode *addNode(int data){    Node *temp = new Node();    temp->data = data;    temp->left = temp->right = NULL;} // utility function to calculate sum// of right leaf nodesvoid rightLeafSum(Node *root, int *sum){    if(!root)        return;     // check if the right child of root    // is leaf node    if(root->right)        if(!root->right->left  &&                      !root->right->right)            *sum += root->right->data;     rightLeafSum(root->left, sum);    rightLeafSum(root->right, sum);} // driver programint main(){             //construct binary tree    Node *root = addNode(1);    root->left = addNode(2);    root->left->left = addNode(4);    root->left->right = addNode(5);    root->left->left->right = addNode(2);    root->right = addNode(3);    root->right->right = addNode(8);    root->right->right->left = addNode(6);    root->right->right->right = addNode(7);     // variable to store sum of right       // leaves    int sum = 0;    rightLeafSum(root, &sum);    cout << sum << endl;    return 0;}
// Java program to find total// sum of right leaf nodesclass GFG{     // sum    static int sum = 0;     // node of binary treestatic class Node{    int data;    Node left, right;}; // return new nodestatic Node addNode(int data){    Node temp = new Node();    temp.data = data;    temp.left = temp.right = null;    return temp;} // utility function to calculate// sum of right leaf nodesstatic void rightLeafSum(Node root){    if(root == null)        return;     // check if the right child    // of root is leaf node    if(root.right != null)        if(root.right.left == null &&           root.right.right == null)            sum += root.right.data;     rightLeafSum(root.left);    rightLeafSum(root.right);} // Driver Codepublic static void main(String args[]){         //construct binary tree    Node root = addNode(1);    root.left = addNode(2);    root.left.left = addNode(4);    root.left.right = addNode(5);    root.left.left.right = addNode(2);    root.right = addNode(3);    root.right.right = addNode(8);    root.right.right.left = addNode(6);    root.right.right.right = addNode(7);         // variable to store sum    // of right leaves    sum = 0;    rightLeafSum(root);    System.out.println( sum );    }} // This code is contributed by Arnab Kundu
# Python3 program to find total Sum# of right leaf nodes # return new nodeclass addNode:    def __init__(self, data):        self.data = data        self.left = self.right = None # utility function to calculate Sum# of right leaf nodesdef rightLeafSum(root, Sum):    if(not root):        return     # check if the right child of root    # is leaf node    if(root.right):        if(not root.right.left and           not root.right.right):            Sum[0] += root.right.data     rightLeafSum(root.left, Sum)    rightLeafSum(root.right, Sum) # Driver Codeif __name__ == '__main__':         # construct binary tree    root = addNode(1)    root.left = addNode(2)    root.left.left = addNode(4)    root.left.right = addNode(5)    root.left.left.right = addNode(2)    root.right = addNode(3)    root.right.right = addNode(8)    root.right.right.left = addNode(6)    root.right.right.right = addNode(7)     # variable to store Sum of right    # leaves    Sum = [0]    rightLeafSum(root, Sum)    print(Sum[0])     # This code is contributed by PranchalK
using System; // C# program to find total // sum of right leaf nodes public class GFG{     // sum    public static int sum = 0; // node of binary tree public class Node{    public int data;    public Node left, right;} // return new node public static Node addNode(int data){    Node temp = new Node();    temp.data = data;    temp.left = temp.right = null;    return temp;} // utility function to calculate // sum of right leaf nodes public static void rightLeafSum(Node root){    if (root == null)    {        return;    }     // check if the right child    // of root is leaf node     if (root.right != null)    {        if (root.right.left == null && root.right.right == null)        {            sum += root.right.data;        }    }     rightLeafSum(root.left);    rightLeafSum(root.right);} // Driver Codepublic static void Main(string[] args){     //construct binary tree     Node root = addNode(1);    root.left = addNode(2);    root.left.left = addNode(4);    root.left.right = addNode(5);    root.left.left.right = addNode(2);    root.right = addNode(3);    root.right.right = addNode(8);    root.right.right.left = addNode(6);    root.right.right.right = addNode(7);     // variable to store sum     // of right leaves     sum = 0;    rightLeafSum(root);    Console.WriteLine(sum);}}   //  This code is contributed by Shrikant13
<script>    // Javascript program to find total    // sum of right leaf nodes         // sum    let sum = 0;         // node of binary tree    class Node    {        constructor(data) {           this.left = null;           this.right = null;           this.data = data;        }    }         // return new node    function addNode(data)    {        let temp = new Node(data);        return temp;    }     // utility function to calculate    // sum of right leaf nodes    function rightLeafSum(root)    {        if(root == null)            return;         // check if the right child        // of root is leaf node        if(root.right != null)            if(root.right.left == null &&               root.right.right == null)                sum += root.right.data;         rightLeafSum(root.left);        rightLeafSum(root.right);    }         //construct binary tree    let root = addNode(1);    root.left = addNode(2);    root.left.left = addNode(4);    root.left.right = addNode(5);    root.left.left.right = addNode(2);    root.right = addNode(3);    root.right.right = addNode(8);    root.right.right.left = addNode(6);    root.right.right.right = addNode(7);          // variable to store sum    // of right leaves    sum = 0;    rightLeafSum(root);    document.write(sum );         // This code is contributed by divyesh072019.</script>
14
Method 2: Iterative Method
The above approach can be done with the help of a queue. The idea is to traverse the tree and whenever we reach the right node check if it is a leaf node. If it is a leaf node then increment the sum.
C++
Java
C#
Javascript
// CPP program to find total sum// of right leaf nodes#include <bits/stdc++.h>using namespace std; // struct node of binary treestruct Node {    int data;    Node *left, *right;}; // return new nodeNode* addNode(int data){    Node* temp = new Node();    temp->data = data;    temp->left = temp->right = NULL;} // utility function to calculate sum// of right leaf nodes iterativelyint rightLeafSum(Node* root){    // declaring sum to store sum of right leaves    int sum = 0;     // queue of Node* type    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 == NULL                and curr->right->left == NULL) {                // incrementing sum for found right leaf                // node                sum += curr->right->data;            }            q.push(curr->right);        }    }    return sum;} // driver programint main(){     // construct binary tree    Node* root = addNode(1);    root->left = addNode(2);    root->left->left = addNode(4);    root->left->right = addNode(5);    root->left->left->right = addNode(2);    root->right = addNode(3);    root->right->right = addNode(8);    root->right->right->left = addNode(6);    root->right->right->right = addNode(7);     int sum = rightLeafSum(root);    cout << sum << endl;    return 0;}
// Java program to find total sum// of right leaf nodesimport java.io.*;import java.util.*; class Node{    int data;    Node left,right;         Node(int data)    {        this.left = null;           this.right = null;           this.data = data;    }     } class GFG{          // return new node    static Node addNode(int data)    {        Node temp = new Node(data);        return temp;    }         // 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 of Node* type        Queue<Node> q = new LinkedList<>();        q.add(root);        while (q.size() > 0)        {            Node curr = q.peek();            q.remove();                       // 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.right == null                    && curr.right.left == null)                {                                       // incrementing sum for found right leaf                    // node                    sum += curr.right.data;                }                q.add(curr.right);            }        }        return sum;    }         // construct binary tree    public static void main (String[] args) {        Node root = addNode(1);        root.left = addNode(2);        root.left.left = addNode(4);        root.left.right = addNode(5);        root.left.left.right = addNode(2);        root.right = addNode(3);        root.right.right = addNode(8);        root.right.right.left = addNode(6);        root.right.right.right = addNode(7);               int sum = rightLeafSum(root);        System.out.println(sum);    }} // This code is contributed by avanitrachhadiya2155.
// C# program to find total sum// of right leaf nodes using System;using System.Collections.Generic;  public   class Node{    public   int data;    public   Node left,right;         public   Node(int data)    {        this.left = null;           this.right = null;           this.data = data;    }     } public class GFG{          // return new node    static Node addNode(int data)    {        Node temp = new Node(data);        return temp;    }         // 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 of Node* type        Queue<Node> q = new Queue<Node>();        q.Enqueue(root);        while (q.Count > 0)        {            Node curr = q.Peek();            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.right == null                    && curr.right.left == null)                {                                       // incrementing sum for found right leaf                    // node                    sum += curr.right.data;                }                q.Enqueue(curr.right);            }        }        return sum;    }         // construct binary tree    public static void Main(String[] args) {        Node root = addNode(1);        root.left = addNode(2);        root.left.left = addNode(4);        root.left.right = addNode(5);        root.left.left.right = addNode(2);        root.right = addNode(3);        root.right.right = addNode(8);        root.right.right.left = addNode(6);        root.right.right.right = addNode(7);               int sum = rightLeafSum(root);        Console.WriteLine(sum);    }}  // This code is contributed by umadevi9616
<script>     // JavaScript program to find total sum    // of right leaf nodes         class Node    {        constructor(data) {           this.left = null;           this.right = null;           this.data = data;        }    }     // return new node    function addNode(data)    {        let temp = new Node(data);        return temp;    }     // utility function to calculate sum    // of right leaf nodes iteratively    function rightLeafSum(root)    {        // declaring sum to store sum of right leaves        let sum = 0;         // queue of Node* type        let q = [];        q.push(root);        while (q.length > 0) {            let curr = q[0];            q.shift();            // check for left node            if (curr.left != null) {                q.push(curr.left);            }            // check for right node            if (curr.right) {                 // check for right leaf node                if (curr.right.right == null                    && curr.right.left == null) {                    // incrementing sum for found right leaf                    // node                    sum += curr.right.data;                }                q.push(curr.right);            }        }        return sum;    }         // construct binary tree    let root = addNode(1);    root.left = addNode(2);    root.left.left = addNode(4);    root.left.right = addNode(5);    root.left.left.right = addNode(2);    root.right = addNode(3);    root.right.right = addNode(8);    root.right.right.left = addNode(6);    root.right.right.right = addNode(7);      let sum = rightLeafSum(root);    document.write(sum); </script>
14
This article is contributed by Mandeep Singh. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above. 
andrew1234
shrikanth13
PranchalKatiyar
Akanksha_Rai
uchiha1101
divyesh072019
suresh07
avanitrachhadiya2155
umadevi9616
Binary Tree
Traversal
Tree
Traversal
Tree
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Comments
Old Comments
Inorder Tree Traversal without Recursion
Binary Tree | Set 3 (Types of Binary Tree)
Binary Tree | Set 2 (Properties)
A program to check if a binary tree is BST or not
Decision Tree
Introduction to Tree Data Structure
Complexity of different operations in Binary tree, Binary Search Tree and AVL tree
Construct Tree from given Inorder and Preorder traversals
Lowest Common Ancestor in a Binary Tree | Set 1