GFG App
Open App
Browser
Continue

# Add all greater values to every node in a given BST

Given a Binary Search Tree (BST), modify it so that all greater values in the given BST are added to every node. For example, consider the following BST.

50
/      \
30        70
/   \      /  \
20    40    60   80

The above tree should be modified to following

260
/      \
330        150
/   \       /  \
350   300    210   80

A simple method for solving this is to find the sum of all greater values for every node. This method would take O(n^2) time.

The method discussed in this article uses the technique of reverse in-order tree traversal of BST which optimizes the problem to be solved in a single traversal.

Approach: In this problem as we could notice that the largest node would remain the same. The value of 2nd largest node = value of largest + value of second largest node. Similarly, the value of nth largest node will be the sum of the n-th node and value of (n-1)th largest node after modification. So if we traverse the tree in descending order and simultaneously update the sum value at every step while adding the value to the root node, the problem would be solved.

So to traverse the BST in descending order we use reverse in-order traversal of BST. This takes a global variable sum which is updated at every node and once the root node is reached it is added to the value of root node and value of the root node is updated.

## C++

 // C++ program to add all greater // values in every node of BST #include using namespace std;   class Node { public:     int data;     Node *left, *right; };   // A utility function to create // a new BST node Node* newNode(int item) {     Node* temp = new Node();     temp->data = item;     temp->left = temp->right = NULL;     return temp; }   // Recursive function to add all // greater values in every node void modifyBSTUtil(Node* root, int* sum) {     // Base Case     if (root == NULL)         return;       // Recur for right subtree     modifyBSTUtil(root->right, sum);       // Now *sum has sum of nodes     // in right subtree, add     // root->data to sum and     // update root->data     *sum = *sum + root->data;     root->data = *sum;       // Recur for left subtree     modifyBSTUtil(root->left, sum); }   // A wrapper over modifyBSTUtil() void modifyBST(Node* root) {     int sum = 0;     modifyBSTUtil(root, &sum); }   // A utility function to do // inorder traversal of BST void inorder(Node* root) {     if (root != NULL) {         inorder(root->left);         cout << root->data << " ";         inorder(root->right);     } }   /* A utility function to insert a new node with given data in BST */ Node* insert(Node* node, int data) {     /* If the tree is empty,        return a new node */     if (node == NULL)         return newNode(data);       /* Otherwise, recur down the tree */     if (data <= node->data)         node->left = insert(node->left, data);     else         node->right = insert(node->right, data);       /* return the (unchanged) node pointer */     return node; }   // Driver code int main() {     /* Let us create following BST             50         / \         30 70         / \ / \     20 40 60 80 */     Node* root = NULL;     root = insert(root, 50);     insert(root, 30);     insert(root, 20);     insert(root, 40);     insert(root, 70);     insert(root, 60);     insert(root, 80);       modifyBST(root);       // print inorder traversal of the modified BST     inorder(root);       return 0; }   // This code is contributed by rathbhupendra

## C

 // C program to add all greater // values in every node of BST #include #include   struct Node {     int data;     struct Node *left, *right; };   // A utility function to create a new BST node struct Node* newNode(int item) {     struct Node* temp         = (struct Node*)malloc(             sizeof(struct Node));     temp->data = item;     temp->left = temp->right = NULL;     return temp; }   // Recursive function to add // all greater values in every node void modifyBSTUtil(     struct Node* root, int* sum) {     // Base Case     if (root == NULL)         return;       // Recur for right subtree     modifyBSTUtil(root->right, sum);       // Now *sum has sum of nodes     // in right subtree, add     // root->data to sum and     // update root->data     *sum = *sum + root->data;     root->data = *sum;       // Recur for left subtree     modifyBSTUtil(root->left, sum); }   // A wrapper over modifyBSTUtil() void modifyBST(struct Node* root) {     int sum = 0;     modifyBSTUtil(root, &sum); }   // A utility function to do // inorder traversal of BST void inorder(struct Node* root) {     if (root != NULL) {         inorder(root->left);         printf("%d ", root->data);         inorder(root->right);     } }   /* A utility function to insert a new node with given data in BST */ struct Node* insert(     struct Node* node, int data) {     /* If the tree is empty, return a new node */     if (node == NULL)         return newNode(data);       /* Otherwise, recur down the tree */     if (data <= node->data)         node->left = insert(node->left, data);     else         node->right = insert(node->right, data);       /* return the (unchanged) node pointer */     return node; }   // Driver Program to test above functions int main() {     /* Let us create following BST               50            /     \           30      70          /  \    /  \        20   40  60   80 */     struct Node* root = NULL;     root = insert(root, 50);     insert(root, 30);     insert(root, 20);     insert(root, 40);     insert(root, 70);     insert(root, 60);     insert(root, 80);       modifyBST(root);       // print inorder traversal of the modified BST     inorder(root);       return 0; }

## Java

 // Java code to add all greater values to // every node in a given BST   // A binary tree node class Node {       int data;     Node left, right;       Node(int d)     {         data = d;         left = right = null;     } }   class BinarySearchTree {       // Root of BST     Node root;       // Constructor     BinarySearchTree()     {         root = null;     }       // Inorder traversal of the tree     void inorder()     {         inorderUtil(this.root);     }       // Utility function for inorder traversal of     // the tree     void inorderUtil(Node node)     {         if (node == null)             return;           inorderUtil(node.left);         System.out.print(node.data + " ");         inorderUtil(node.right);     }       // adding new node     public void insert(int data)     {         this.root = this.insertRec(this.root, data);     }       /* A utility function to insert a new node with     given data in BST */     Node insertRec(Node node, int data)     {         /* If the tree is empty, return a new node */         if (node == null) {             this.root = new Node(data);             return this.root;         }           /* Otherwise, recur down the tree */         if (data <= node.data) {             node.left = this.insertRec(node.left, data);         }         else {             node.right = this.insertRec(node.right, data);         }         return node;     }       // This class initialises the value of sum to 0     public class Sum {         int sum = 0;     }       // Recursive function to add all greater values in     // every node     void modifyBSTUtil(Node node, Sum S)     {         // Base Case         if (node == null)             return;           // Recur for right subtree         this.modifyBSTUtil(node.right, S);           // Now *sum has sum of nodes in right subtree, add         // root->data to sum and update root->data         S.sum = S.sum + node.data;         node.data = S.sum;           // Recur for left subtree         this.modifyBSTUtil(node.left, S);     }       // A wrapper over modifyBSTUtil()     void modifyBST(Node node)     {         Sum S = new Sum();         this.modifyBSTUtil(node, S);     }       // Driver Function     public static void main(String[] args)     {         BinarySearchTree tree = new BinarySearchTree();           /* Let us create following BST               50            /     \           30      70          /  \    /  \        20   40  60   80 */           tree.insert(50);         tree.insert(30);         tree.insert(20);         tree.insert(40);         tree.insert(70);         tree.insert(60);         tree.insert(80);           tree.modifyBST(tree.root);           // print inorder traversal of the modified BST         tree.inorder();     } }   // This code is contributed by Kamal Rawal

## Python3

 # Python3 program to add all greater values # in every node of BST   # A utility function to create a # new BST node class newNode:       # Constructor to create a new node     def __init__(self, data):         self.data = data         self.left = None         self.right = None   # Recursive function to add all greater # values in every node def modifyBSTUtil(root, Sum):           # Base Case     if root == None:         return       # Recur for right subtree     modifyBSTUtil(root.right, Sum)       # Now Sum[0] has sum of nodes in right     # subtree, add root.data to sum and     # update root.data     Sum[0] = Sum[0] + root.data     root.data = Sum[0]       # Recur for left subtree     modifyBSTUtil(root.left, Sum)   # A wrapper over modifyBSTUtil() def modifyBST(root):     Sum = [0]     modifyBSTUtil(root, Sum)   # A utility function to do inorder # traversal of BST def inorder(root):     if root != None:         inorder(root.left)         print(root.data, end =" ")         inorder(root.right)   # A utility function to insert a new node # with given data in BST def insert(node, data):           # If the tree is empty, return a new node     if node == None:         return newNode(data)       # Otherwise, recur down the tree     if data <= node.data:         node.left = insert(node.left, data)     else:         node.right = insert(node.right, data)       # return the (unchanged) node pointer     return node   # Driver Code if __name__ == '__main__':           # Let us create following BST     # 50     #     /     \     # 30     70     #     / \ / \     # 20 40 60 80     root = None     root = insert(root, 50)     insert(root, 30)     insert(root, 20)     insert(root, 40)     insert(root, 70)     insert(root, 60)     insert(root, 80)       modifyBST(root)       # print inorder traversal of the     # modified BST     inorder(root)       # This code is contributed by PranchalK

## C#

 using System;   // C# code to add all greater values to // every node in a given BST   // A binary tree node public class Node {       public int data;     public Node left, right;       public Node(int d)     {         data = d;         left = right = null;     } }   public class BinarySearchTree {       // Root of BST     public Node root;       // Constructor     public BinarySearchTree()     {         root = null;     }       // Inorder traversal of the tree     public virtual void inorder()     {         inorderUtil(this.root);     }       // Utility function for inorder traversal of     // the tree     public virtual void inorderUtil(Node node)     {         if (node == null) {             return;         }           inorderUtil(node.left);         Console.Write(node.data + " ");         inorderUtil(node.right);     }       // adding new node     public virtual void insert(int data)     {         this.root = this.insertRec(this.root, data);     }       /* A utility function to insert a new node with      given data in BST */     public virtual Node insertRec(Node node, int data)     {         /* If the tree is empty, return a new node */         if (node == null) {             this.root = new Node(data);             return this.root;         }           /* Otherwise, recur down the tree */         if (data <= node.data) {             node.left = this.insertRec(node.left, data);         }         else {             node.right = this.insertRec(node.right, data);         }         return node;     }       // This class initialises the value of sum to 0     public class Sum {         private readonly BinarySearchTree outerInstance;           public Sum(BinarySearchTree outerInstance)         {             this.outerInstance = outerInstance;         }           public int sum = 0;     }       // Recursive function to add all greater values in     // every node     public virtual void modifyBSTUtil(Node node, Sum S)     {         // Base Case         if (node == null) {             return;         }           // Recur for right subtree         this.modifyBSTUtil(node.right, S);           // Now *sum has sum of nodes in right subtree, add         // root->data to sum and update root->data         S.sum = S.sum + node.data;         node.data = S.sum;           // Recur for left subtree         this.modifyBSTUtil(node.left, S);     }       // A wrapper over modifyBSTUtil()     public virtual void modifyBST(Node node)     {         Sum S = new Sum(this);         this.modifyBSTUtil(node, S);     }       // Driver Function     public static void Main(string[] args)     {         BinarySearchTree tree = new BinarySearchTree();           /* Let us create following BST               50            /     \           30      70          /  \    /  \        20   40  60   80 */           tree.insert(50);         tree.insert(30);         tree.insert(20);         tree.insert(40);         tree.insert(70);         tree.insert(60);         tree.insert(80);           tree.modifyBST(tree.root);           // print inorder traversal of the modified BST         tree.inorder();     } }   // This code is contributed by Shrikant13

## Javascript



Output

350 330 300 260 210 150 80

Complexity Analysis:

• Time Complexity: O(n).
As this problem uses an in-order tree traversal technique
• Auxiliary Space: O(1).
As no data structure has been used for storing values.

Approach 2: Recursive Inorder Traversal

In this approach, we traverse the BST in reverse inorder traversal, which gives us the nodes in descending order. While traversing, we maintain a variable sum that keeps track of the sum of all greater nodes than the current node. We add the sum to the current node’s value and update the sum to the new value. This way, we update all nodes with the sum of all greater nodes.

Initialize a variable sum to 0.
Traverse the given BST in reverse inorder (right, root, left) and for each node:
a. Add the node’s value to sum.
b. Replace the node’s value with sum.
Return the modified BST.

The reverse inorder traversal ensures that we visit the nodes in descending order, which allows us to calculate the sum of all greater values for each node. By keeping track of the running sum, we can easily update each node’s value with the sum of all greater values.

## C++

 #include using namespace std;   struct Node {     int data;     Node *left, *right; };   Node* newNode(int data) {     Node* node = new Node;     node->data = data;     node->left = node->right = NULL;     return node; }   void modifyBSTUtil(Node* root, int* sum) {     if (root == NULL) return;       modifyBSTUtil(root->right, sum);       *sum = *sum + root->data;     root->data = *sum;       modifyBSTUtil(root->left, sum); }   void modifyBST(Node* root) {     int sum = 0;     modifyBSTUtil(root, &sum); }   void inorder(Node* root) {     if (root == NULL) return;       inorder(root->left);     cout << root->data << " ";     inorder(root->right); }   int main() {     Node* root = newNode(50);     root->left = newNode(30);     root->right = newNode(70);     root->left->left = newNode(20);     root->left->right = newNode(40);     root->right->left = newNode(60);     root->right->right = newNode(80);                 modifyBST(root);           inorder(root);       return 0; }

## Javascript

 // Define a Node class with a constructor that sets the data, left, and right properties. class Node {     constructor(data) {         this.data = data;         this.left = this.right = null;     } }   // Create a new Node with the given data. function newNode(data) {     let node = new Node(data);     return node; }   // Utility function to modify the BST (binary search tree). function modifyBSTUtil(root, sum) {     // If the root node is null, return.     if (root == null) return;       // Recursively call modifyBSTUtil on the right subtree.     modifyBSTUtil(root.right, sum);       // Add the data value of the current node to the sum.     sum[0] = sum[0] + root.data;     // Set the data value of the current node to the sum.     root.data = sum[0];       // Recursively call modifyBSTUtil on the left subtree.     modifyBSTUtil(root.left, sum); }   // Function to modify the BST by calling modifyBSTUtil with an initial sum of 0. function modifyBST(root) {     let sum = [0];     modifyBSTUtil(root, sum); }   // Function to perform an inorder traversal of the BST and print the values. function inorder(root) {     // If the root node is null, return.     if (root == null) return;       // Recursively call inorder on the left subtree.     inorder(root.left);     // Print the data value of the current node.     console.log(root.data + " ");     // Recursively call inorder on the right subtree.     inorder(root.right); }   // Create a new BST with the given nodes. let root = newNode(50); root.left = newNode(30); root.right = newNode(70); root.left.left = newNode(20); root.left.right = newNode(40); root.right.left = newNode(60); root.right.right = newNode(80);   // Modify the BST. modifyBST(root);   // Perform an inorder traversal and print the values. inorder(root);

## Python3

 class Node:     def __init__(self, data):         self.data = data         self.left = None         self.right = None   def newNode(data):     node = Node(data)     return node   def modifyBSTUtil(root, sum):     if root is None:         return           modifyBSTUtil(root.right, sum)           sum[0] += root.data     root.data = sum[0]           modifyBSTUtil(root.left, sum)   def modifyBST(root):     sum = [0]     modifyBSTUtil(root, sum)   def inorder(root):     if root is None:         return           inorder(root.left)     print(root.data, end=' ')     inorder(root.right)   if __name__ == '__main__':     root = newNode(50)     root.left = newNode(30)     root.right = newNode(70)     root.left.left = newNode(20)     root.left.right = newNode(40)     root.right.left = newNode(60)     root.right.right = newNode(80)           modifyBST(root)           inorder(root)

Output

350 330 300 260 210 150 80

Time Complexity: O(n), where n is the number of nodes in the BST.
Auxiliary Space: O(h), where h is the height of the BST.

My Personal Notes arrow_drop_up