Related Articles
Convert a BST to a Binary Tree such that sum of all greater keys is added to every key
• Difficulty Level : Easy
• Last Updated : 08 Mar, 2021

Given a Binary Search Tree (BST), convert it to a Binary Tree such that every key of the original BST is changed to key plus sum of all greater keys in BST.
Examples:

Input: Root of following BST
5
/   \
2     13

Output: The given BST is converted to following Binary Tree
18
/   \
20     13

Method 1:
Solution: Do reverse Inoorder traversal. Keep track of the sum of nodes visited so far. Let this sum be sum. For every node currently being visited, first add the key of this node to sum, i.e. sum = sum + node->key. Then change the key of current node to sum, i.e., node->key = sum
When a BST is being traversed in reverse Inorder, for every key currently being visited, all keys that are already visited are all greater keys.

## C++

 // C++ Program to change a BST to Binary Tree// such that key of a node becomes original// key plus sum of all greater keys in BST#include using namespace std; /* A BST node has key, left child   and right child */struct node{    int key;    struct node* left;    struct node* right;}; /* Helper function that allocates a new nodewith the given key and NULL left and right pointers.*/struct node* newNode(int key){    struct node* node = (struct node*)malloc(sizeof(struct node));    node->key = key;    node->left = NULL;    node->right = NULL;    return (node);} // A recursive function that traverses the// given BST in reverse inorder and for// every key, adds all greater keys to itvoid addGreaterUtil(struct node *root, int *sum_ptr){    // Base Case    if (root == NULL)        return;     // Recur for right subtree first so that sum    // of all greater nodes is stored at sum_ptr    addGreaterUtil(root->right, sum_ptr);     // Update the value at sum_ptr    *sum_ptr = *sum_ptr + root->key;     // Update key of this node    root->key = *sum_ptr;     // Recur for left subtree so that the    // updated sum is added to smaller nodes    addGreaterUtil(root->left, sum_ptr);} // A wrapper over addGreaterUtil(). It initializes// sum and calls addGreaterUtil() to recursively// update and use value of sumvoid addGreater(struct node *root){    int sum = 0;    addGreaterUtil(root, &sum);} // A utility function to print inorder// traversal of Binary Treevoid printInorder(struct node* node){    if (node == NULL)        return;    printInorder(node->left);    cout << node->key << " " ;    printInorder(node->right);} // Driver Codeint main(){    /* Create following BST            5            / \        2 13 */    node *root = newNode(5);    root->left = newNode(2);    root->right = newNode(13);     cout << "Inorder traversal of the "         << "given tree" << endl;    printInorder(root);     addGreater(root);    cout << endl;    cout << "Inorder traversal of the "         << "modified tree" << endl;    printInorder(root);     return 0;} // This code is contributed by SHUBHAMSINGH10

## C

 // Program to change a BST to Binary Tree such that key of a node becomes// original key plus sum of all greater keys in BST#include #include  /* A BST node has key, left child and right child */struct node{    int key;    struct node* left;    struct node* right;}; /* Helper function that allocates a new node with the given key and   NULL left and right  pointers.*/struct node* newNode(int key){    struct node* node = (struct node*)malloc(sizeof(struct node));    node->key = key;    node->left = NULL;    node->right = NULL;    return (node);} // A recursive function that traverses the given BST in reverse inorder and// for every key, adds all greater keys to itvoid addGreaterUtil(struct node *root, int *sum_ptr){    // Base Case    if (root == NULL)        return;     // Recur for right subtree first so that sum of all greater    // nodes is stored at sum_ptr    addGreaterUtil(root->right, sum_ptr);     // Update the value at sum_ptr    *sum_ptr = *sum_ptr + root->key;     // Update key of this node    root->key = *sum_ptr;     // Recur for left subtree so that the updated sum is added    // to smaller nodes    addGreaterUtil(root->left, sum_ptr);} // A wrapper over addGreaterUtil().  It initializes sum and calls// addGreaterUtil() to recursivel upodate and use value of sumvoid addGreater(struct node *root){    int sum = 0;    addGreaterUtil(root, &sum);} // A utility function to print inorder traversal of Binary Treevoid printInorder(struct node* node){    if (node == NULL)        return;    printInorder(node->left);    printf("%d ", node->key);    printInorder(node->right);} // Driver program to test above functionint main(){    /* Create following BST              5            /   \           2     13  */    node *root = newNode(5);    root->left = newNode(2);    root->right = newNode(13);     printf("Inorder traversal of the given tree\n");    printInorder(root);     addGreater(root);     printf("\nInorder traversal of the modified tree\n");    printInorder(root);     return 0;}

## Python3

 # Python3 Program to change a BST to# Binary Tree such that key of a node# becomes original key plus sum of all# greater keys in BST # A BST node has key, left child and# right child */class Node:     # Constructor to create a new node    def __init__(self, data):        self.key = data        self.left = None        self.right = None # A recursive function that traverses# the given BST in reverse inorder and# for every key, adds all greater keys to itdef addGreaterUtil(root, sum_ptr):         # Base Case    if root == None:        return     # Recur for right subtree first so that sum    # of all greater nodes is stored at sum_ptr    addGreaterUtil(root.right, sum_ptr)     # Update the value at sum_ptr    sum_ptr[0] = sum_ptr[0] + root.key     # Update key of this node    root.key = sum_ptr[0]     # Recur for left subtree so that the    # updated sum is added to smaller nodes    addGreaterUtil(root.left, sum_ptr) # A wrapper over addGreaterUtil(). It initializes# sum and calls addGreaterUtil() to recursive# update and use value of sumdef addGreater(root):    Sum = [0]    addGreaterUtil(root, Sum)     # A utility function to print inorder# traversal of Binary Treedef printInorder(node):    if node == None:        return    printInorder(node.left)    print(node.key, end = " ")    printInorder(node.right) # Driver Codeif __name__ == '__main__':         # Create following BST    #         5    #     / \    #     2     13    root = Node(5)    root.left = Node(2)    root.right = Node(13)     print("Inorder traversal of the given tree")    printInorder(root)     addGreater(root)    print()    print("Inorder traversal of the modified tree")    printInorder(root) # This code is contributed by PranchalK

## C#

Output:

Inorder traversal of the given tree
2 5 13
Inorder traversal of the modified tree
20 18 13

Time Complexity: O(n) where n is the number of nodes in given Binary Search Tree.

Method 2:

The below method uses the technique of Iteration with the Stack.

Approach:

1. First, we initialize an empty stack and set the current node to the root.
2. Then, so long as there are unvisited nodes in the stack or the node does not point to null, we push all of the nodes along the path to the rightmost leaf onto the stack.
3. . Next, we visit the node on the top of our stack and consider its left subtree.
4. Eventually, our stack is empty and the node points to the left null child of the tree’s minimum value node, so the loop terminates.

Below is the implementation of the above approach:

## C

 #include #include #define bool int /* A binary tree tNode has data, pointer to left childand a pointer to right child */struct tNode {    int data;    struct tNode* left;    struct tNode* right;}; /* Structure of a stack node. Linked List implementation isused for stack. A stack node contains a pointer to tree nodeand a pointer to next stack node */struct sNode {    struct tNode* t;    struct sNode* next;}; /* Stack related functions */void push(struct sNode** top_ref, struct tNode* t);struct tNode* pop(struct sNode** top_ref);bool isEmpty(struct sNode* top); /* Iterative function for inorder tree traversal */void inOrder(struct tNode* root){    /* set current to root of binary tree */    struct tNode* current = root;    struct sNode* s = NULL; /* Initialize stack s */    bool done = 0;     while (!done) {        /* Reach the left most tNode of the current tNode */        if (current != NULL) {            /* place pointer to a tree node on the stack               before traversing the node's left subtree */            push(&s, current);            current = current->left;        }         /* backtrack from the empty subtree and visit the        tNode at the top of the stack; however, if the stack        is empty, you are done */        else {            if (!isEmpty(s)) {                current = pop(&s);                printf("%d ", current->data);                 /* we have visited the node and its left                subtree. Now, it's right subtree's turn */                current = current->right;            }            else                done = 1;        }    } /* end of while */} void Greater_BST(struct tNode* root){    int sum = 0;    struct sNode* st = NULL;    struct tNode* node = root;     while (!isEmpty(st) || node != NULL) {        // push all nodes up to (and including) this        // subtree's maximum on the stack         while (node != NULL) {            push(&st, node);            node = node->right;        }         node = pop(&st);         sum += node->data;        node->data = sum;         // all nodes with values between the current and its        // parent lie in the left subtree.        node = node->left;    }} /* UTILITY FUNCTIONS *//* Function to push an item to sNode*/void push(struct sNode** top_ref, struct tNode* t){    /* allocate tNode */    struct sNode* new_tNode        = (struct sNode*)malloc(sizeof(struct sNode));     if (new_tNode == NULL) {        printf("Stack Overflow \n");        getchar();        exit(0);    }     /* put in the data */    new_tNode->t = t;     /* link the old list off the new tNode */    new_tNode->next = (*top_ref);     /* move the head to point to the new tNode */    (*top_ref) = new_tNode;} /* The function returns true if stack is empty, otherwise * false */bool isEmpty(struct sNode* top){    return (top == NULL) ? 1 : 0;} /* Function to pop an item from stack*/struct tNode* pop(struct sNode** top_ref){    struct tNode* res;    struct sNode* top;     top = *top_ref;    res = top->t;    *top_ref = top->next;    free(top);    return res;} /* Helper function that allocates a new tNode with thegiven data and NULL left and right pointers. */struct tNode* newtNode(int data){    struct tNode* tNode        = (struct tNode*)malloc(sizeof(struct tNode));    tNode->data = data;    tNode->left = NULL;    tNode->right = NULL;     return (tNode);} /* Driver program to test above functions*/int main(){     /* Let us create following BST                          8                /     \              5        12             /  \      /  \           2     7    9    15     */     struct tNode* root = newtNode(8);    root->left = newtNode(5);    root->right = newtNode(12);    root->left->left = newtNode(2);    root->left->right = newtNode(7);    root->right->left = newtNode(9);    root->right->right = newtNode(15);     Greater_BST(root);     inOrder(root);     getchar();    return 0;}

## C++

 // C++ program to add all greater// values in every node of BST through Iteration using Stack#include using namespace std; class Node {public:    int data;    Node *left, *right;}; // A utility function to create// a new BST nodeNode* newNode(int item){    Node* temp = new Node();    temp->data = item;    temp->left = temp->right = NULL;    return temp;} // Iterative function to add// all greater values in every nodevoid Greater_BST(Node* root){    int sum = 0;        stack st;        Node* node = root;                 while(!st.empty() || node != NULL ){        // push all nodes up to (and including) this subtree's maximum on the stack                          while(node != NULL){                st.push(node);                node = node->right;            }                      node = st.top();            st.pop();            sum += node->data;            node->data = sum;              // all nodes with values between the current and its parent lie in the left subtree.            node = node->left;        }} // A utility function to do// inorder traversal of BSTvoid inorder(Node* root){    if (root != NULL) {        inorder(root->left);        cout << root->data << " ";        inorder(root->right);    }} /* A utility function to inserta 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 codeint main(){    /* Let us create following BST              8            /     \          5        12         /  \      /  \       2     7    9    15 */       Node* root = NULL;    root = insert(root, 8);    insert(root, 5);    insert(root, 2);    insert(root, 7);    insert(root, 12);    insert(root, 9);    insert(root, 15);     Greater_BST(root);     // print inoder tarversal of the Greater BST    inorder(root);     return 0;}

## Java

 // Java code to add all greater values to// every node in a given BST import java.util.*; // A binary tree nodeclass 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;    }     // Iterative function to add    // all greater values in every node    void Greater_BST(Node root)    {        int sum = 0;        Node node = root;        Stack stack = new Stack();         while (!stack.isEmpty() || node != null) {            /* push all nodes up to (and including) this             * subtree's maximum on the stack. */            while (node != null) {                stack.add(node);                node = node.right;            }             node = stack.pop();            sum += node.data;            node.data = sum;             /* all nodes with values between the current and             * its parent lie in the left subtree. */            node = node.left;        }    }     // Driver Function    public static void main(String[] args)    {        BinarySearchTree tree = new BinarySearchTree();         /* Let us create following BST            8         /     \   5     12  / \   / \ 2   7 9   15   */         tree.insert(8);        tree.insert(5);        tree.insert(2);        tree.insert(7);        tree.insert(12);        tree.insert(9);        tree.insert(15);         tree.Greater_BST(tree.root);         // print inoder tarversal of the Greater BST        tree.inorder();    }}

## Python3

 # Python3 program to add all greater values# in every node of BST through Iteration using Stack # A utility function to create a# new BST nodeclass newNode:     # Constructor to create a new node    def __init__(self, data):        self.data = data        self.left = None        self.right = None  # Iterative function to add all greater# values in every node def Greater_BST(root):    total = 0             node = root    stack = []    while stack or node is not None:               # push all nodes up to (and including)        # this subtree's maximum on        # the stack.        while node is not None:            stack.append(node)            node = node.right         node = stack.pop()        total += node.data        node.data = total         # all nodes with values between        # the current and its parent lie in        # the left subtree.        node = node.left # A utility function to do inorder# traversal of BSTdef 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 BSTdef 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 Codeif __name__ == '__main__':         # Let us create following BST    #        8    #     /     \    #   5     12    #  / \   / \    # 2   7 9   15    root = None    root = insert(root, 8)    insert(root, 5)    insert(root, 2)    insert(root, 7)    insert(root, 9)    insert(root, 12)    insert(root, 15)     Greater_BST(root)     # print inoder tarversal of the    # Greater BST    inorder(root)

Output:

58 56 51 44 36 27 15

Time Complexity: O(n) , n is no.of Node in a BST.

Auxiliary Space: O(n). Stack is used for storing data.

?list=PLqM7alHXFySHCXD7r1J0ky9Zg_GBB1dbk