Change a Binary Tree so that every node stores sum of all nodes in left subtree - GeeksforGeeks

28 Feb, 2022
Given a Binary Tree, change the value in each node to sum of all the values in the nodes in the left subtree including its own.Examples: 
Input : 
     1
   /   \
 2      3

Output :
    3
  /   \
 2     3


Input
       1
      / \
     2   3
    / \   \
   4   5   6
Output:
      12
     / \
    6   3
   / \   \
  4   5   6
We strongly recommend you to minimize your browser and try this yourself first.The idea is to traverse the given tree in bottom up manner. For every node, recursively compute sum of nodes in left and right subtrees. Add sum of nodes in left subtree to current node and return sum of nodes under current subtree.Below is the implementation of above idea.  
C++
C
Java
Python3
C#
Javascript
// C++ program to store sum of nodes// in left subtree in every node#include<bits/stdc++.h> using namespace std; // A tree nodeclass node{    public:    int data;    node* left, *right;         /* Constructor that allocates a new node with the    given data and NULL left and right pointers. */    node(int data)    {        this->data = data;        this->left = NULL;        this->right = NULL;    }}; // Function to modify a Binary Tree// so that every node stores sum of// values in its left child including// its own valueint updatetree(node *root){    // Base cases    if (!root)        return 0;    if (root->left == NULL && root->right == NULL)        return root->data;     // Update left and right subtrees    int leftsum = updatetree(root->left);    int rightsum = updatetree(root->right);     // Add leftsum to current node    root->data += leftsum;     // Return sum of values under root    return root->data + rightsum;} // Utility function to do inorder traversalvoid inorder(node* node){    if (node == NULL)        return;    inorder(node->left);    cout<<node->data<<" ";    inorder(node->right);} // Driver codeint main(){    /* Let us construct below tree                1            / \            2 3            / \ \            4 5 6 */    struct node *root = new node(1);    root->left     = new node(2);    root->right = new node(3);    root->left->left = new node(4);    root->left->right = new node(5);    root->right->right = new node(6);     updatetree(root);     cout << "Inorder traversal of the modified tree is: \n";    inorder(root);    return 0;} // This code is contributed by rathbhupendra
// C program to store  sum of nodes in left subtree in every// node#include<bits/stdc++.h>using namespace std; // A tree nodestruct node{    int data;    struct node* left,  *right;}; // Function to modify a Binary Tree so that every node// stores sum of values in its left child including its// own valueint updatetree(node *root){    // Base cases    if (!root)        return 0;    if (root->left == NULL && root->right == NULL)        return root->data;     // Update left and right subtrees    int leftsum  = updatetree(root->left);    int rightsum = updatetree(root->right);     // Add leftsum to current node    root->data += leftsum;     // Return sum of values under root    return root->data + rightsum;} // Utility function to do inorder traversalvoid inorder(struct node* node){    if (node == NULL)        return;    inorder(node->left);    printf("%d ", node->data);    inorder(node->right);} // Utility function to create a new nodestruct node* newNode(int data){    struct node* node =        (struct node*)malloc(sizeof(struct node));    node->data = data;    node->left = NULL;    node->right = NULL;    return(node);} // Driver programint main(){    /* Let us construct below tree                1               / \              2   3             / \   \            4   5   6    */    struct node *root  = newNode(1);    root->left         = newNode(2);    root->right        = newNode(3);    root->left->left   = newNode(4);    root->left->right  = newNode(5);    root->right->right = newNode(6);     updatetree(root);     cout << "Inorder traversal of the modified tree is \n";    inorder(root);    return 0;}
// Java program to store sum of nodes in left subtree in every// nodeclass GfG { // A tree nodestatic class node{    int data;    node left, right;} // Function to modify a Binary Tree so that every node// stores sum of values in its left child including its// own valuestatic int updatetree(node root){    // Base cases    if (root == null)        return 0;    if (root.left == null && root.right == null)        return root.data;     // Update left and right subtrees    int leftsum = updatetree(root.left);    int rightsum = updatetree(root.right);     // Add leftsum to current node    root.data += leftsum;     // Return sum of values under root    return root.data + rightsum;} // Utility function to do inorder traversalstatic void inorder(node node){    if (node == null)        return;    inorder(node.left);    System.out.print(node.data + " ");    inorder(node.right);} // Utility function to create a new nodestatic node newNode(int data){    node node = new node();    node.data = data;    node.left = null;    node.right = null;    return(node);} // Driver programpublic static void main(String[] args){    /* Let us construct below tree                1            / \            2 3            / \ \            4 5 6 */    node root = newNode(1);    root.left         = newNode(2);    root.right     = newNode(3);    root.left.left = newNode(4);    root.left.right = newNode(5);    root.right.right = newNode(6);     updatetree(root);          System.out.println("Inorder traversal of the modified tree is");    inorder(root);}}
# Python3 program to store sum of nodes# in left subtree in every node # Binary Tree Node # utility that allocates a new Node# with the given keyclass newNode:     # Construct to create a new node    def __init__(self, key):        self.data = key        self.left = None        self.right = None # Function to modify a Binary Tree so# that every node stores sum of values# in its left child including its own valuedef updatetree(root):         # Base cases    if (not root):        return 0    if (root.left == None and        root.right == None) :        return root.data     # Update left and right subtrees    leftsum = updatetree(root.left)    rightsum = updatetree(root.right)     # Add leftsum to current node    root.data += leftsum     # Return sum of values under root    return root.data + rightsum # Utility function to do inorder traversaldef inorder(node) :     if (node == None) :        return    inorder(node.left)    print(node.data, end = " ")    inorder(node.right) # Driver Codeif __name__ == '__main__':         """ Let us construct below tree                    1                / \                2 3                / \ \                4 5 6 """    root = newNode(1)    root.left = newNode(2)    root.right = newNode(3)    root.left.left = newNode(4)    root.left.right = newNode(5)    root.right.right = newNode(6)     updatetree(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 left // subtree in every nodeusing System; class GfG{ // A tree nodeclass node{    public int data;    public node left, right;} // Function to modify a Binary Tree so// that every node stores sum of values// in its left child including its own valuestatic int updatetree(node root){    // Base cases    if (root == null)        return 0;    if (root.left == null && root.right == null)        return root.data;     // Update left and right subtrees    int leftsum = updatetree(root.left);    int rightsum = updatetree(root.right);     // Add leftsum to current node    root.data += leftsum;     // Return sum of values under root    return root.data + rightsum;} // Utility function to do inorder traversalstatic void inorder(node node){    if (node == null)        return;    inorder(node.left);    Console.Write(node.data + " ");    inorder(node.right);} // Utility function to create a new nodestatic node newNode(int data){    node node = new node();    node.data = data;    node.left = null;    node.right = null;    return(node);} // Driver codepublic static void Main(){    /* Let us construct below tree                1            / \            2 3            / \ \            4 5 6 */    node root = newNode(1);    root.left = newNode(2);    root.right = newNode(3);    root.left.left = newNode(4);    root.left.right = newNode(5);    root.right.right = newNode(6);     updatetree(root);     Console.WriteLine("Inorder traversal of the modified tree is");    inorder(root);}} /* This code is contributed by Rajput-Ji*/
<script>  // Javascript program to store sum of nodes in left // subtree in every node // A tree nodeclass node{  constructor()  {    this.data = 0;    this.left = null;    this.right = null;  }} // Function to modify a Binary Tree so// that every node stores sum of values// in its left child including its own valuefunction updatetree(root){    // Base cases    if (root == null)        return 0;    if (root.left == null && root.right == null)        return root.data;     // Update left and right subtrees    var leftsum = updatetree(root.left);    var rightsum = updatetree(root.right);     // Add leftsum to current node    root.data += leftsum;     // Return sum of values under root    return root.data + rightsum;} // Utility function to do inorder traversalfunction inorder(node){    if (node == null)        return;    inorder(node.left);    document.write(node.data + " ");    inorder(node.right);} // Utility function to create a new nodefunction newNode(data){    var nod = new node();    nod.data = data;    nod.left = null;    nod.right = null;    return(nod);} // Driver code/* Let us construct below tree            1        / \        2 3        / \ \        4 5 6 */var root = newNode(1);root.left = newNode(2);root.right = newNode(3);root.left.left = newNode(4);root.left.right = newNode(5);root.right.right = newNode(6);updatetree(root);document.write("Inorder traversal of the modified tree is<br>");inorder(root); // This code is contributed by rrrtnx.</script>
Output: 
Inorder traversal of the modified tree is
4 6 5 12 3 6
Time Complexity: O(n) 
https://www.youtube.com/watch?v=EkmG
-FKRjBQ 
Thanks to Gaurav Ahrirwar for suggesting this solution.Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above 
 
prerna saini
Rajput-Ji
SHUBHAMSINGH10
rathbhupendra
rrrtnx
surinderdawra388
Tree
Tree
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Tree Traversals (Inorder, Preorder and Postorder)
Binary Tree | Set 1 (Introduction)
Level Order Binary Tree Traversal
AVL Tree | Set 1 (Insertion)
Inorder Tree Traversal without Recursion
Binary Tree | Set 3 (Types of Binary Tree)
Write a Program to Find the Maximum Depth or Height of a Tree
Binary Tree | Set 2 (Properties)
A program to check if a binary tree is BST or not