# Convert a Binary Tree such that every node stores the sum of all nodes in its right subtree

Given a binary tree, change the value in each node to sum of all the values in the nodes in the right subtree including its own.

Examples:

```Input :
1
/   \
2      3
Output :
4
/   \
2     3

Input :
1
/ \
2   3
/ \   \
4   5   6
Output :
10
/ \
7   9
/ \   \
4   5   6
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach : The idea is to traverse the given binary tree in bottom up manner. Recursively compute the sum of nodes in right and left subtrees. Accumulate sum of nodes in the right subtree to the current node and return sum of nodes under current subtree.

Below is the implementation of above approach.

 `// C++ program to store sum of nodes in ` `// right subtree in every node ` `#include ` `using` `namespace` `std; ` ` `  `// Node of tree ` `struct` `Node { ` `    ``int` `data; ` `    ``Node *left, *right; ` `}; ` ` `  `// Function to create a new node ` `struct` `Node* createNode(``int` `item) ` `{ ` `    ``Node* temp = ``new` `Node; ` `    ``temp->data = item; ` `    ``temp->left = NULL; ` `    ``temp->right = NULL; ` ` `  `    ``return` `temp; ` `} ` ` `  `// Function to build new tree with  ` `// all nodes having the sum of all  ` `// nodes in its right subtree ` `int` `updateBTree(Node* root) ` `{ ` `    ``// Base cases ` `    ``if` `(!root) ` `        ``return` `0; ` `    ``if` `(root->left == NULL && root->right == NULL) ` `        ``return` `root->data; ` ` `  `    ``// Update right and left subtrees ` `    ``int` `rightsum = updateBTree(root->right); ` `    ``int` `leftsum = updateBTree(root->left); ` ` `  `    ``// Add rightsum to current node ` `    ``root->data += rightsum; ` ` `  `    ``// Return sum of values under root ` `    ``return` `root->data + leftsum; ` `} ` ` `  `// Function to traverse tree in inorder way ` `void` `inorder(``struct` `Node* node) ` `{ ` `    ``if` `(node == NULL) ` `        ``return``; ` `    ``inorder(node->left); ` `    ``cout << node->data << ``" "``; ` `    ``inorder(node->right); ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``/* Let us construct a binary tree ` `            ``1 ` `           ``/ \ ` `          ``2   3 ` `         ``/ \   \ ` `        ``4   5   6       */` `    ``struct` `Node* root = NULL; ` `    ``root = createNode(1); ` `    ``root->left = createNode(2); ` `    ``root->right = createNode(3); ` `    ``root->left->left = createNode(4); ` `    ``root->left->right = createNode(5); ` `    ``root->right->right = createNode(6); ` ` `  `    ``// new tree construction ` `    ``updateBTree(root); ` ` `  `    ``cout << ``"Inorder traversal of the modified tree is \n"``; ` `    ``inorder(root); ` ` `  `    ``return` `0; ` `} `

 `// Java program to store sum of nodes in  ` `// right subtree in every node  ` `class` `GFG ` `{ ` ` `  `// Node of tree  ` `static` `class` `Node  ` `{  ` `    ``int` `data;  ` `    ``Node left, right;  ` `};  ` ` `  `// Function to create a new node  ` `static` `Node createNode(``int` `item)  ` `{  ` `    ``Node temp = ``new` `Node();  ` `    ``temp.data = item;  ` `    ``temp.left = ``null``;  ` `    ``temp.right = ``null``;  ` ` `  `    ``return` `temp;  ` `}  ` ` `  `// Function to build new tree with  ` `// all nodes having the sum of all  ` `// nodes in its right subtree  ` `static` `int` `updateBTree(Node root)  ` `{  ` `    ``// Base cases  ` `    ``if` `(root == ``null``)  ` `        ``return` `0``;  ` `    ``if` `(root.left == ``null` `&& root.right == ``null``)  ` `        ``return` `root.data;  ` ` `  `    ``// Update right and left subtrees  ` `    ``int` `rightsum = updateBTree(root.right);  ` `    ``int` `leftsum = updateBTree(root.left);  ` ` `  `    ``// Add rightsum to current node  ` `    ``root.data += rightsum;  ` ` `  `    ``// Return sum of values under root  ` `    ``return` `root.data + leftsum;  ` `}  ` ` `  `// Function to traverse tree in inorder way  ` `static` `void` `inorder( Node node)  ` `{  ` `    ``if` `(node == ``null``)  ` `        ``return``;  ` `    ``inorder(node.left);  ` `    ``System.out.print( node.data + ``" "``);  ` `    ``inorder(node.right);  ` `}  ` ` `  `// Driver code  ` `public` `static` `void` `main(String args[]) ` `{  ` `    ``/* Let us construct a binary tree  ` `        ``1  ` `        ``/ \  ` `        ``2 3  ` `        ``/ \ \  ` `        ``4 5 6 */` `    ``Node root = ``null``;  ` `    ``root = createNode(``1``);  ` `    ``root.left = createNode(``2``);  ` `    ``root.right = createNode(``3``);  ` `    ``root.left.left = createNode(``4``);  ` `    ``root.left.right = createNode(``5``);  ` `    ``root.right.right = createNode(``6``);  ` ` `  `    ``// new tree conion  ` `    ``updateBTree(root);  ` ` `  `    ``System.out.print( ``"Inorder traversal of the modified tree is \n"``);  ` `    ``inorder(root);  ` `} ` `}  ` ` `  `// This code is contributed by Arnab Kundu `

 `# Program to convert expression tree  ` `# from prefix expression ` ` `  `# Helper function that allocates a new  ` `# node with the given data and None  ` `# left and right poers.                                  ` `class` `createNode:  ` ` `  `    ``# Conto create a new node  ` `    ``def` `__init__(``self``, key):  ` `        ``self``.data ``=` `key ` `        ``self``.left ``=` `None` `        ``self``.right ``=` `None` `         `  `# Function to build new tree with  ` `# all nodes having the sum of all  ` `# nodes in its right subtree ` `def` `updateBTree( root): ` ` `  `    ``# Base cases ` `    ``if` `(``not` `root): ` `        ``return` `0` `    ``if` `(root.left ``=``=` `None` `and` `        ``root.right ``=``=` `None``): ` `        ``return` `root.data ` ` `  `    ``# Update right and left subtrees ` `    ``rightsum ``=` `updateBTree(root.right) ` `    ``leftsum ``=` `updateBTree(root.left) ` ` `  `    ``# Add rightsum to current node ` `    ``root.data ``+``=` `rightsum ` ` `  `    ``# Return sum of values under root ` `    ``return` `root.data ``+` `leftsum ` ` `  `# Function to traverse tree in inorder way ` `def` `inorder(node): ` ` `  `    ``if` `(node ``=``=` `None``): ` `        ``return` `    ``inorder(node.left) ` `    ``print``(node.data, end ``=` `" "``) ` `    ``inorder(node.right) ` ` `  `# Driver Code  ` `if` `__name__ ``=``=` `'__main__'``: ` `     `  `    ``""" Let us convert binary tree ` `        ``1 ` `    ``/ \ ` `    ``2 3 ` `    ``/ \ \ ` `    ``4 5 6 """` `    ``root ``=` `None` `    ``root ``=` `createNode(``1``) ` `    ``root.left ``=` `createNode(``2``) ` `    ``root.right ``=` `createNode(``3``) ` `    ``root.left.left ``=` `createNode(``4``) ` `    ``root.left.right ``=` `createNode(``5``) ` `    ``root.right.right ``=` `createNode(``6``) ` ` `  `    ``# new tree construction ` `    ``updateBTree(root) ` ` `  `    ``print``(``"Inorder traversal of the"``,  ` `          ``"modified tree is"``) ` `    ``inorder(root) ` ` `  `# This code is contributed by ` `# Shubham Singh(SHUBHAMSINGH10) `

 `// C# program to store sum of nodes in  ` `// right subtree in every node  ` `using` `System; ` `     `  `class` `GFG ` `{ ` ` `  `// Node of tree  ` `public` `class` `Node  ` `{  ` `    ``public` `int` `data;  ` `    ``public` `Node left, right;  ` `};  ` ` `  `// Function to create a new node  ` `static` `Node createNode(``int` `item)  ` `{  ` `    ``Node temp = ``new` `Node();  ` `    ``temp.data = item;  ` `    ``temp.left = ``null``;  ` `    ``temp.right = ``null``;  ` ` `  `    ``return` `temp;  ` `}  ` ` `  `// Function to build new tree with  ` `// all nodes having the sum of all  ` `// nodes in its right subtree  ` `static` `int` `updateBTree(Node root)  ` `{  ` `    ``// Base cases  ` `    ``if` `(root == ``null``)  ` `        ``return` `0;  ` `    ``if` `(root.left == ``null` `&& root.right == ``null``)  ` `        ``return` `root.data;  ` ` `  `    ``// Update right and left subtrees  ` `    ``int` `rightsum = updateBTree(root.right);  ` `    ``int` `leftsum = updateBTree(root.left);  ` ` `  `    ``// Add rightsum to current node  ` `    ``root.data += rightsum;  ` ` `  `    ``// Return sum of values under root  ` `    ``return` `root.data + leftsum;  ` `}  ` ` `  `// Function to traverse tree in inorder way  ` `static` `void` `inorder( Node node)  ` `{  ` `    ``if` `(node == ``null``)  ` `        ``return``;  ` `    ``inorder(node.left);  ` `    ``Console.Write( node.data + ``" "``);  ` `    ``inorder(node.right);  ` `}  ` ` `  `// Driver code  ` `public` `static` `void` `Main(String[] args) ` `{  ` `    ``/* Let us construct a binary tree  ` `        ``1  ` `        ``/ \  ` `        ``2 3  ` `        ``/ \ \  ` `        ``4 5 6 */` `    ``Node root = ``null``;  ` `    ``root = createNode(1);  ` `    ``root.left = createNode(2);  ` `    ``root.right = createNode(3);  ` `    ``root.left.left = createNode(4);  ` `    ``root.left.right = createNode(5);  ` `    ``root.right.right = createNode(6);  ` ` `  `    ``// new tree conion  ` `    ``updateBTree(root);  ` ` `  `    ``Console.Write( ``"Inorder traversal of the modified tree is \n"``);  ` `    ``inorder(root);  ` `} ` `} ` ` `  `// This code contributed by Rajput-Ji `

Output:
```Inorder traversal of the modified tree is
4 7 5 10 9 6
```

Time Complexity: O(n)

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.

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Article Tags :
Practice Tags :