Open In App

Find sum of all right leaves in a given Binary Tree

Improve
Improve
Like Article
Like
Save
Share
Report

Given a Binary Tree, find sum of all right leaves in it. 
Similar article: Find sum of all left leaves in a given Binary Tree

Example : 

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++




// CPP program to find total sum
// of right leaf nodes
#include <bits/stdc++.h>
using namespace std;
 
// struct node of binary tree
struct Node {
    int data;
    Node *left, *right;
};
 
// return new node
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
void 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 == NULL
            && root->right->right == NULL)
            sum += root->right->data;
 
    rightLeafSum(root->left, sum);
    rightLeafSum(root->right, sum);
}
 
// driver program
int 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




<div id="highlighter_370266" class="syntaxhighlighter nogutter  "><table border="0" cellpadding="0" cellspacing="0"><tbody><tr><td class="code"><div class="container"><div class="line number1 index0 alt2"><code class="comments">// Java program to find total</code></div><div class="line number2 index1 alt1"><code class="comments">// sum of right leaf nodes</code></div><div class="line number3 index2 alt2"><code class="keyword">class</code> <code class="plain">GFG {</code></div><div class="line number4 index3 alt1"> </div><div class="line number5 index4 alt2"><code class="undefined spaces">    </code><code class="comments">// sum</code></div><div class="line number6 index5 alt1"><code class="undefined spaces">    </code><code class="keyword">static</code> <code class="keyword">int</code> <code class="plain">sum = </code><code class="value">0</code><code class="plain">;</code></div><div class="line number7 index6 alt2"> </div><div class="line number8 index7 alt1"><code class="undefined spaces">    </code><code class="comments">// node of binary tree</code></div><div class="line number9 index8 alt2"><code class="undefined spaces">    </code><code class="keyword">static</code> <code class="keyword">class</code> <code class="plain">Node {</code></div><div class="line number10 index9 alt1"><code class="undefined spaces">        </code><code class="keyword">int</code> <code class="plain">data;</code></div><div class="line number11 index10 alt2"><code class="undefined spaces">        </code><code class="plain">Node left, right;</code></div><div class="line number12 index11 alt1"><code class="undefined spaces">    </code><code class="plain">};</code></div><div class="line number13 index12 alt2"> </div><div class="line number14 index13 alt1"><code class="undefined spaces">    </code><code class="comments">// return new node</code></div><div class="line number15 index14 alt2"><code class="undefined spaces">    </code><code class="keyword">static</code> <code class="plain">Node addNode(</code><code class="keyword">int</code> <code class="plain">data)</code></div><div class="line number16 index15 alt1"><code class="undefined spaces">    </code><code class="plain">{</code></div><div class="line number17 index16 alt2"><code class="undefined spaces">        </code><code class="plain">Node temp = </code><code class="keyword">new</code> <code class="plain">Node();</code></div><div class="line number18 index17 alt1"><code class="undefined spaces">        </code><code class="plain">temp.data = data;</code></div><div class="line number19 index18 alt2"><code class="undefined spaces">        </code><code class="plain">temp.left = temp.right = </code><code class="keyword">null</code><code class="plain">;</code></div><div class="line number20 index19 alt1"><code class="undefined spaces">        </code><code class="keyword">return</code> <code class="plain">temp;</code></div><div class="line number21 index20 alt2"><code class="undefined spaces">    </code><code class="plain">}</code></div><div class="line number22 index21 alt1"> </div><div class="line number23 index22 alt2"><code class="undefined spaces">    </code><code class="comments">// utility function to calculate</code></div><div class="line number24 index23 alt1"><code class="undefined spaces">    </code><code class="comments">// sum of right leaf nodes</code></div><div class="line number25 index24 alt2"><code class="undefined spaces">    </code><code class="keyword">static</code> <code class="keyword">void</code> <code class="plain">rightLeafSum(Node root)</code></div><div class="line number26 index25 alt1"><code class="undefined spaces">    </code><code class="plain">{</code></div><div class="line number27 index26 alt2"><code class="undefined spaces">        </code><code class="keyword">if</code> <code class="plain">(root == </code><code class="keyword">null</code><code class="plain">)</code></div><div class="line number28 index27 alt1"><code class="undefined spaces">            </code><code class="keyword">return</code><code class="plain">;</code></div><div class="line number29 index28 alt2"> </div><div class="line number30 index29 alt1"><code class="undefined spaces">        </code><code class="comments">// check if the right child</code></div><div class="line number31 index30 alt2"><code class="undefined spaces">        </code><code class="comments">// of root is leaf node</code></div><div class="line number32 index31 alt1"><code class="undefined spaces">        </code><code class="keyword">if</code> <code class="plain">(root.right != </code><code class="keyword">null</code><code class="plain">)</code></div><div class="line number33 index32 alt2"><code class="undefined spaces">            </code><code class="keyword">if</code> <code class="plain">(root.right.left == </code><code class="keyword">null</code></div><div class="line number34 index33 alt1"><code class="undefined spaces">                </code><code class="plain">&& root.right.right == </code><code class="keyword">null</code><code class="plain">)</code></div><div class="line number35 index34 alt2"><code class="undefined spaces">                </code><code class="plain">sum += root.right.data;</code></div><div class="line number36 index35 alt1"> </div><div class="line number37 index36 alt2"><code class="undefined spaces">        </code><code class="plain">rightLeafSum(root.left);</code></div><div class="line number38 index37 alt1"><code class="undefined spaces">        </code><code class="plain">rightLeafSum(root.right);</code></div><div class="line number39 index38 alt2"><code class="undefined spaces">    </code><code class="plain">}</code></div><div class="line number40 index39 alt1"> </div><div class="line number41 index40 alt2"><code class="undefined spaces">    </code><code class="comments">// Driver Code</code></div><div class="line number42 index41 alt1"><code class="undefined spaces">    </code><code class="keyword">public</code> <code class="keyword">static</code> <code class="keyword">void</code> <code class="plain">main(String args[])</code></div><div class="line number43 index42 alt2"><code class="undefined spaces">    </code><code class="plain">{</code></div><div class="line number44 index43 alt1"> </div><div class="line number45 index44 alt2"><code class="undefined spaces">        </code><code class="comments">// construct binary tree</code></div><div class="line number46 index45 alt1"><code class="undefined spaces">        </code><code class="plain">Node root = addNode(</code><code class="value">1</code><code class="plain">);</code></div><div class="line number47 index46 alt2"><code class="undefined spaces">        </code><code class="plain">root.left = addNode(</code><code class="value">2</code><code class="plain">);</code></div><div class="line number48 index47 alt1"><code class="undefined spaces">        </code><code class="plain">root.left.left = addNode(</code><code class="value">4</code><code class="plain">);</code></div><div class="line number49 index48 alt2"><code class="undefined spaces">        </code><code class="plain">root.left.right = addNode(</code><code class="value">5</code><code class="plain">);</code></div><div class="line number50 index49 alt1"><code class="undefined spaces">        </code><code class="plain">root.left.left.right = addNode(</code><code class="value">2</code><code class="plain">);</code></div><div class="line number51 index50 alt2"><code class="undefined spaces">        </code><code class="plain">root.right = addNode(</code><code class="value">3</code><code class="plain">);</code></div><div class="line number52 index51 alt1"><code class="undefined spaces">        </code><code class="plain">root.right.right = addNode(</code><code class="value">8</code><code class="plain">);</code></div><div class="line number53 index52 alt2"><code class="undefined spaces">        </code><code class="plain">root.right.right.left = addNode(</code><code class="value">6</code><code class="plain">);</code></div><div class="line number54 index53 alt1"><code class="undefined spaces">        </code><code class="plain">root.right.right.right = addNode(</code><code class="value">7</code><code class="plain">);</code></div><div class="line number55 index54 alt2"> </div><div class="line number56 index55 alt1"><code class="undefined spaces">        </code><code class="comments">// variable to store sum</code></div><div class="line number57 index56 alt2"><code class="undefined spaces">        </code><code class="comments">// of right leaves</code></div><div class="line number58 index57 alt1"><code class="undefined spaces">        </code><code class="plain">sum = </code><code class="value">0</code><code class="plain">;</code></div><div class="line number59 index58 alt2"><code class="undefined spaces">        </code><code class="plain">rightLeafSum(root);</code></div><div class="line number60 index59 alt1"><code class="undefined spaces">        </code><code class="plain">System.out.println(sum);</code></div><div class="line number61 index60 alt2"><code class="undefined spaces">    </code><code class="plain">}</code></div><div class="line number62 index61 alt1"><code class="plain">}</code></div><div class="line number63 index62 alt2"> </div><div class="line number64 index63 alt1"><code class="comments">// This code is contributed by Arnab Kundu</code></div></div></td></tr></tbody></table></div>


Python3




# Python3 program to find total Sum
# of right leaf nodes
 
# return new node
 
 
class addNode:
    def __init__(self, data):
        self.data = data
        self.left = self.right = None
 
# utility function to calculate Sum
# of right leaf nodes
 
 
def 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 Code
if __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


C#




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 Code
    public 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


Javascript





Output

14

Time Complexity: O(n), As we are visiting every node.
Auxiliary Space: O(h), Here h is height of the tree and the extra space is used due to recursion call stack.

Another Method:

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. For right node we pass it as true, and false for left node. Time Complexity of this method is also O(n).

C++





Java





Python3





C#





Javascript




// Javascript program to find total sum of right leaf nodes.
 
// struct node of Binary Tree
class Node {
    constructor(data)
    {
        this.data=data;
        this.left=null;
        this.right=null;
    }
};
 
/*// fun to create and return a new node
 addNode(int data)
{
    Node* temp = new Node();
    temp.data = data;
    temp.left = temp.right = NULL;
    return temp;
}*/
 
// fun to calculate sum of right leaf nodes
function rightLeafSum(root, 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);
}
 
    // create a tree
    let root = new Node(1);
    root.left = new Node(2);
    root.left.left = new Node(4);
    root.left.right = new Node(5);
    root.left.left.right = new Node(2);
    root.right = new Node(3);
    root.right.right = new Node(8);
    root.right.right.left = new Node(6);
    root.right.right.right = new Node(7);
 
    console.log(rightLeafSum(root, false));
 
   // This code is contributed by poojaagarwal2.


Output

14

Time Complexity: O(n), As we are visiting every node.
Auxiliary Space: O(h), Here h is height of the tree and extra space is used dur to recursion call stack.

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.

Implementation:

C++




// CPP program to find total sum
// of right leaf nodes
#include <bits/stdc++.h>
using namespace std;
 
// struct node of binary tree
struct Node {
    int data;
    Node *left, *right;
};
 
// return new node
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 iteratively
int 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 program
int 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




// Java program to find total sum
// of right leaf nodes
import 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.


Python3




# Python3 program to find total sum
# of right leaf nodes
 
# Return new node
 
 
class addNode:
    def __init__(self, data):
        self.data = data
        self.left = self.right = None
 
# Utility function to calculate Sum
# of right leaf nodes
def rightLeafSum(root):
    # Declaring sum to store sum of right leaves
    sum = 0
 
    # Queue of Node* type
    q = []
    q.append(root)
    while (len(q) > 0):
        curr = q.pop(0)
 
        # Check for left node
        if (curr.left != None):
            q.append(curr.left)
 
        # Check for right node
        if (curr.right != None):
            # Check for right leaf node
            if (curr.right.right == None and curr.right.left == None):
                # Incrementing sum for found right leaf
                # node
                sum += curr.right.data
 
            q.append(curr.right)
 
    return sum
 
 
# Driver Code
if __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 = rightLeafSum(root)
    print(sum)
 
# This code is contributed by Abhijeet Kumar(abhijeet19403)


C#




// 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


Javascript




<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>


Output

14

Time Complexity: O(n), As we are visiting every node.
Auxiliary Space: O(b), Here b is breadth of the tree and the extra space is used due to storing of the elements in the queue.

Another Iterative Approach(using Stack):
Follow the below steps to solve this problem:
1) Initialize a stack and perform any traversal(Inorder, Preorder or Postorder).
2) check for every node if right of that node is not null and a leaf node that add this node data into sum variable.
3) return sum.

Below is the implementation of above approach:

C++




// C++ program to find sum of all right leaves
#include<bits/stdc++.h>
using namespace std;
  
// A binary tree node
struct Node{
    int data;
    Node* left, *right;
    // A constructor to create a new Node
    Node(int key){
        data = key;
        left = NULL;
        right = NULL;
    }
};
  
// Return the sum of right leaf nodes
int sumOfRightLeaves(Node* root){
    if(root == NULL)
        return 0;
         
    // Using a stack_ for Depth-First
    // Traversal of the tree
    stack<Node*> st;
    st.push(root);
      
    // sum holds the sum of all the left leaves
    int sum = 0;
    while(st.size() > 0){
        Node* currentNode = st.top();
        st.pop();
  
        if (currentNode->right != NULL){
            st.push(currentNode->right);
            // Check if currentNode's left
            // child is a leaf node
            if(currentNode->right->left == NULL &&
               currentNode->right->right == NULL){
                // if currentNode is a leaf,
                // add its data to the sum
                sum = sum + currentNode->right->data ;
            }
        }
        if (currentNode->left != NULL)
            st.push(currentNode->left);
    }
    return sum;
}
  
// Driver Code to test above function
int main(){
    Node *root = new Node(1);
    root->left= new Node(2);
    root->left->left = new Node(4);
    root->left->right = new Node(5);
    root->left->left->right = new Node(2);
    root->right = new Node(3);
    root->right->right = new Node(8);
    root->right->right->left = new Node(6);
    root->right->right->right = new Node(7);
      
    cout << "Sum of right leaves is : "<<sumOfRightLeaves(root)<<endl;
    return 0;
}
// THIS CODE IS CONTRIBUTED BY YASH AGARWAL(YASHAGARWAL2852002)


Java




// Java Program to get intersection point of two linked list
import java.io.*;
import java.util.*;
 
public class BinaryTree{
    static class Node{
        int data;
        Node left;
        Node right;
        Node(int d){
            data = d;
            left = null;
            right = null;
        }
    }
     
    static int sumOfRightLeaves(Node root){
        if(root == null) return 0;
         
        // using a stack_ for depth first
        // traversal of the tree
        Stack<Node> st = new Stack<Node>();
        st.push(root);
         
        // sum holds the sum of all the left leaves
        int sum = 0;
        while(!st.isEmpty()){
            Node currentNode = st.pop();
            if(currentNode.right != null){
                st.push(currentNode.right);
                // check if currentNode's left
                // child is a leaf node
                if(currentNode.right.left == null && currentNode.right.right == null){
                    sum = sum + currentNode.right.data;
                }
            }
            if(currentNode.left != null){
                st.push(currentNode.left);
            }
        }
        return sum;
    }
     
    public static void main(String[] args){
        Node root = new Node(1);
        root.left = new Node(2);
        root.left.left = new Node(4);
        root.left.right = new Node(5);
        root.left.left.right = new Node(2);
        root.right = new Node(3);
        root.right.right = new Node(8);
        root.right.right.left = new Node(6);
        root.right.right.right = new Node(7);
         
        System.out.print("Sum of right leaves is : " + sumOfRightLeaves(root));
    }
}


Python




# Python program to find sum of all right leaves
# a binary tree node
class Node:
    def __init__(self, data):
        self.data = data
        self.left = None
        self.right = None
         
# return the sum of right leaf nodes
def sumOfRightLeaves(root):
    if(root is None):
        return 0
       
    # using a stack for depth first
    # traversal of the tree
    st = []
    st.append(root)
     
    # sum holds the sum of all the left leaves
    sum = 0
    while(len(st) > 0):
        currentNode = st.pop(0)
         
        if(currentNode.right is not None):
            st.append(currentNode.right)
             
            # check if currentnode's left
            # child is a leaf node
            if(currentNode.right.left is None and currentNode.right.right is None):
                # if currentNode is a leaf,
                # add its data to the sum
                sum = sum + currentNode.right.data
                 
        if(currentNode.left is not None):
            st.append(currentNode.left)
    return sum
 
 
# driver code to test above function
root = Node(1)
root.left = Node(2)
root.left.left = Node(4)
root.left.right = Node(5)
root.left.left.right = Node(2)
root.right = Node(3)
root.right.right = Node(8)
root.right.right.left = Node(6)
root.right.right.right = Node(7)
 
print("Sum of right leaves is : ")
print(sumOfRightLeaves(root))


C#




// C# Program to find sum of all right leaves
// THIS CODE IS CONTRIBUTED BY YASH AGARWAL
using System;
using System.Collections.Generic;
 
// a binary tree node
public class Node{
    public int data;
    public Node left, right;
    // a constructor to create a new node
    public Node(int key){
        data = key;
        left = null;
        right = null;
    }
}
 
class GFG{
    // return the sum of right leaf nodes
    static int sumOfRightLeaves(Node root){
        if(root == null) return 0;
         
        // using a stack_ for depth first
        // traversal of the tree
        Stack<Node> st = new Stack<Node>();
        st.Push(root);
         
        // sum holds the sum of all the left leaves
        int sum = 0;
        while(st.Count > 0){
            Node currentNode = st.Pop();
            if(currentNode.right != null){
                st.Push(currentNode.right);
                // check if currentNode left
                // child is a leaf node
                if(currentNode.right.left == null && currentNode.right.right == null){
                    // if currentNode is a leaf
                    // node add its data to the sum
                    sum += currentNode.right.data;
                }
            }
            if(currentNode.left != null){
                st.Push(currentNode.left);
            }
        }
        return sum;
    }
     
    // driver code to test above function
    public static void Main(String[] args){
        Node root = new Node(1);
        root.left = new Node(2);
        root.left.left = new Node(4);
        root.left.right = new Node(5);
        root.left.left.right = new Node(2);
        root.right = new Node(3);
        root.right.right = new Node(8);
        root.right.right.left = new Node(6);
        root.right.right.right = new Node(7);
         
        Console.WriteLine("Sum of right leaves is : " + sumOfRightLeaves(root));
    }
}


Javascript




// Javascript program to find sum of all right leaves
// a binary tree node
class Node{
    constructor(data){
        this.data = data;
        this.left = null;
        this.right = null;
    }
}
 
// return the sum of right leaf nodes
function sumOfRightLeaves(root){
    if(root == null) return 0;
     
    // using a stack_for depth first search
    // traversal of the tree
    let st = [];
    st.push(root);
     
    // sum holds the sum of all the left leaves
    let sum = 0;
    while(st.length > 0){
        let currentNode = st.pop();
        if(currentNode.right != null){
            st.push(currentNode.right);
             
            // check if currentnode's left
            // child is a leaf node
            if(currentNode.right.left == null && currentNode.right.right == null){
                sum = sum + currentNode.right.data;
            }
        }
        if(currentNode.left != null)
            st.push(currentNode.left);
    }
    return sum;
}
 
// driver code to test above function
let root = new Node(1);
root.left= new Node(2);
root.left.left = new Node(4);
root.left.right = new Node(5);
root.left.left.right = new Node(2);
root.right = new Node(3);
root.right.right = new Node(8);
root.right.right.left = new Node(6);
root.right.right.right = new Node(7);
 
console.log("Sum of right leaves is : " + sumOfRightLeaves(root));


Output

Sum of right leaves is : 14

Time Complexity: O(N) where N is the number of nodes in given binary tree.
Auxiliary Space: O(N) due to stack data structure.

 



Last Updated : 15 Mar, 2023
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads