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.
// 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;
} |
<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 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 |
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 |
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).
// 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.
|
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:
// 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 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 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# 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
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++ 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 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 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# 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 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));
|
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.