Find sum of all right leaves in a given Binary Tree

• Difficulty Level : Easy
• Last Updated : 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 Tree
Example :

```Input :
1
/  \
2    3
/  \     \
4    5     8
\        /  \
2       6   7

Output :
sum = 2 + 5 + 7 = 14```

Method 1: Recursive Method

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

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;``}` `// 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  && ``                     ``!root->right->right)``            ``*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`

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

 `// 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;``}` `// 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.`

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`

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.