Open In App

# Find sum of all right leaves in a given Binary Tree

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

 `// Java program to find total``// sum of right leaf nodes``class` `GFG {` `    ``// sum``    ``static` `int` `sum = ``0``;` `    ``// node of binary tree``    ``static` `class` `Node {``        ``int` `data;``        ``Node left, right;``    ``};` `    ``// return new node``    ``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``    ``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);``        ``System.out.println(sum);``    ``}``}` `// This code is contributed by Arnab Kundu`

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

 `// C++ program to find total sum of right leaf nodes.``#include ``using` `namespace` `std;` `// struct node of Binary Tree``struct` `Node {``    ``int` `data;``    ``Node *left, *right;``};` `// fun to create and return a new node``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``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()``{``    ``// create a 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);` `    ``cout << rightLeafSum(root, ``false``);` `    ``return` `0;``}``// This code is contributed by Modem Upendra`

## Java

 `// Java program to find total sum of right leaf nodes.``import` `java.util.*;` `public` `class` `GFG {` `  ``// structure of node of Binary Tree``  ``static` `class` `Node {``    ``int` `data;``    ``Node left, right;` `    ``Node(``int` `item)``    ``{``      ``data = item;``      ``left = right = ``null``;``    ``}``  ``}` `  ``// fun to calculate sum of right leaf nodes``  ``static` `int` `rightLeafSum(Node root, ``boolean` `isrightleaf)``  ``{``    ``// base case``    ``if` `(root == ``null``)``      ``return` `0``;` `    ``// if it is a leaf node and right node, the return``    ``// root's data.``    ``if` `(root.left == ``null` `&& root.right == ``null``        ``&& 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``);``  ``}``  ``public` `static` `void` `main(String[] args)``  ``{``    ` `    ``// create a tree``    ``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.println(rightLeafSum(root, ``false``));``  ``}``}` `// This code is contributed by Karandeep1234`

## Python3

 `# Python code for the above approach``# Class of the tree Node``class` `Node:``    ``def` `__init__(``self``, data):``        ``self``.data ``=` `data``        ``self``.left ``=` `None``        ``self``.right ``=` `None` `def` `addNode(data):``    ``temp ``=` `Node(data)``    ``return` `temp``  ` `# fun to calculate sum of right leaf nodes``def` `rightLeafSum(root, isrightleaf):``    ``# base case``    ``if` `not` `root:``        ``return` `0``      ` `# if it is a leaf node and right node, the return``# root's data.``    ``if` `not` `root.left ``and` `not` `root.right ``and` `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``)` `if` `__name__ ``=``=` `"__main__"``:``  ` `    ``# create a 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``)` `    ``print``(rightLeafSum(root, ``False``))` `# This code is contributed by lokeshpotta20.`

## C#

 `// C# program to find total sum of right leaf nodes.` `using` `System;` `public` `class` `GFG {` `  ``// structure of node of Binary Tree``  ``public` `class` `Node {``    ``public` `int` `data;``    ``public` `Node left, right;` `    ``public` `Node(``int` `item)``    ``{``      ``data = item;``      ``left = right = ``null``;``    ``}``  ``}` `  ``// fun to calculate sum of right leaf nodes``  ``static` `int` `rightLeafSum(Node root, ``bool` `isrightleaf)``  ``{``    ``// base case``    ``if` `(root == ``null``)``      ``return` `0;` `    ``// if it is a leaf node and right node, the return``    ``// root's data.``    ``if` `(root.left == ``null` `&& root.right == ``null``        ``&& 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``);``  ``}``  ``public` `static` `void` `Main(``string``[] args)``  ``{` `    ``// create a tree``    ``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(rightLeafSum(root, ``false``));``  ``}``}` `// This Code is contributed by karandeep1234`

## 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 ``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 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 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 q = ``new` `Queue();``        ``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

 ``

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``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 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 : "``<

## 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 st = ``new` `Stack();``        ``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 st = ``new` `Stack();``        ``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.

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.