Transform a BST to greater sum tree

Last Updated : 05 Oct, 2024

Given a BST, transform it into a greater sum tree where each node contains the sum of all nodes greater than that node.

Example:

Input:

Output:

Explanation: The above tree represents the greater sum tree where each node contains the sum of all nodes greater than that node in original tree.
The root node 11 becomes 119 (sum of 15 + 29 + 35 + 40).
The left child of 11 becomes 137 (sum of 7 + 11 + 15 + 29 + 35 + 40).
The right child of 11 becomes 75 (sum of 35 + 40) and so on.

Table of Content

[Naive Approach] By Calculating Sum for Each Node - O(n^2) Time and O(n) Space

This method doesn’t require the tree to be a BST. Following are the steps:
Traverse node by node (in-order, pre-order, etc.).
For each node, find all the nodes greater than the current node and sum their values. Store all these sums.
Replace each node's value with its corresponding sum by traversing in the same order as in Step 1.

Below is the implementation of the above approach:

C++

// C++ program to transform a BST to sum tree

#include <bits/stdc++.h>
using namespace std;

class Node {
public:
    int data;
    Node* left;
    Node* right;

    Node(int value) {
        data = value;
        left = nullptr;
        right = nullptr;
    }
};

// Function to find nodes having greater value than current node.
void findGreaterNodes(Node* root, Node* curr, unordered_map<Node*,int> &map) {
    if (root == nullptr) return;
    
    // if value is greater than node, then increment 
    // it in the map
    if (root->data > curr->data) 
        map[curr] += root->data;
        
    findGreaterNodes(root->left, curr, map);
    findGreaterNodes(root->right, curr, map);
}

void transformToGreaterSumTree(Node* curr, Node* root, 
                               unordered_map<Node*,int>&map) {
    if (curr == nullptr) {
        return;
    }

    // Find all nodes greater than current node
    findGreaterNodes(root, curr, map);
    
    // Recursively check for left and right subtree.
    transformToGreaterSumTree(curr->left, root, map);
    transformToGreaterSumTree(curr->right, root, map);
}

// Function to update value of each node.
void preOrderTrav(Node* root, unordered_map<Node*, int> &map) {
    if (root == nullptr) return;
    
    root->data = map[root];
    
    preOrderTrav(root->left, map);
    preOrderTrav(root->right, map);
}

void transformTree(Node* root) {
  
  	// map to store greater sum for each node.
  	unordered_map<Node*, int> map;
    transformToGreaterSumTree(root, root, map);
    
    // update the value of nodes
    preOrderTrav(root, map);
}

void inorder(Node* root) {
    if (root == nullptr) {
        return;
    }
    inorder(root->left);
    cout << root->data << " ";
    inorder(root->right);
}

int main() {

    // Constructing the BST
    //     11
    //    /  \
    //   2    29
    //  / \   / \
    // 1   7 15  40
    //             \
    //              50

    Node* root = new Node(11);
    root->left = new Node(2);
    root->right = new Node(29);
    root->left->left = new Node(1);
    root->left->right = new Node(7);
    root->right->left = new Node(15);
    root->right->right = new Node(40);
    root->right->right->right = new Node(50);

    transformTree(root);
    inorder(root);

    return 0;
}

Java

// Java program to transform a BST to sum tree
import java.util.HashMap;

class Node {
    int data;
    Node left, right;

    Node(int value) {
        data = value;
        left = null;
        right = null;
    }
}

class GfG {
    
    // Function to find nodes having greater value than
   // current node.
    static void findGreaterNodes(Node root, Node curr, 
                                 HashMap<Node, Integer> map) {
        if (root == null) return;

        // if value is greater than node, then increment
        // it in the map
        if (root.data > curr.data)
            map.put(curr, map.getOrDefault(curr, 0) + root.data);

        findGreaterNodes(root.left, curr, map);
        findGreaterNodes(root.right, curr, map);
    }

    static void transformToGreaterSumTree(Node curr, Node root,
                                          HashMap<Node, Integer> map) {
        if (curr == null) {
            return;
        }

        // Find all nodes greater than current node
        findGreaterNodes(root, curr, map);

        // Recursively check for left and right subtree.
        transformToGreaterSumTree(curr.left, root, map);
        transformToGreaterSumTree(curr.right, root, map);
    }

    // Function to update value of each node.
    static void preOrderTrav(Node root, HashMap<Node, Integer> map) {
        if (root == null) return;

        root.data = map.getOrDefault(root, 0);

        preOrderTrav(root.left, map);
        preOrderTrav(root.right, map);
    }
  
    static void transformTree(Node root) {
        
        // map to store greater sum for each node.
        HashMap<Node, Integer> map = new HashMap<>();
        transformToGreaterSumTree(root, root, map);

        // update the value of nodes
        preOrderTrav(root, map);
    }

    static void inorder(Node root) {
        if (root == null) {
            return;
        }
        inorder(root.left);
        System.out.print(root.data + " ");
        inorder(root.right);
    }

    public static void main(String[] args) {
        
        // Constructing the BST
        //     11
        //    /  \
        //   2    29
        //  / \   / \
        // 1   7 15  40
        //             \
        //              50
        Node root = new Node(11);
        root.left = new Node(2);
        root.right = new Node(29);
        root.left.left = new Node(1);
        root.left.right = new Node(7);
        root.right.left = new Node(15);
        root.right.right = new Node(40);
        root.right.right.right = new Node(50);

        transformTree(root);
        inorder(root);
    }
}

Python

# Python program to transform a BST
# to sum tree

class Node:
    def __init__(self, value):
        self.data = value
        self.left = None
        self.right = None

# Function to find nodes having greater 
# value than current node.
def findGreaterNodes(root, curr, map):
    if root is None:
        return
    
    # if value is greater than node, then increment
    # it in the map
    if root.data > curr.data:
        map[curr] += root.data

    findGreaterNodes(root.left, curr, map)
    findGreaterNodes(root.right, curr, map)

def transformToGreaterSumTree(curr, root, map):
    if curr is None:
        return

    # Find all nodes greater than current node
    map[curr] = 0
    findGreaterNodes(root, curr, map)

    # Recursively check for left and right subtree.
    transformToGreaterSumTree(curr.left, root, map)
    transformToGreaterSumTree(curr.right, root, map)

# Function to update value of each node.
def preOrderTrav(root, map):
    if root is None:
        return
    
    root.data = map.get(root, root.data)
    
    preOrderTrav(root.left, map)
    preOrderTrav(root.right, map)

def transformTree(root):
    
    # map to store greater sum for each node.
    map = {}
    transformToGreaterSumTree(root, root, map)
    
    # update the value of nodes
    preOrderTrav(root, map)

def inorder(root):
    if root is None:
        return
    inorder(root.left)
    print(root.data, end=" ")
    inorder(root.right)

if __name__ == "__main__":
    
    # Constructing the BST
    #     11
    #    /  \
    #   2    29
    #  / \   / \
    # 1   7 15  40
    #             \
    #              50
    root = Node(11)
    root.left = Node(2)
    root.right = Node(29)
    root.left.left = Node(1)
    root.left.right = Node(7)
    root.right.left = Node(15)
    root.right.right = Node(40)
    root.right.right.right = Node(50)
    
    transformTree(root)
    inorder(root)

// C# program to transform a BST
// to sum tree
using System;
using System.Collections.Generic;

class Node {
    public int data;
    public Node left, right;

    public Node(int value) {
        data = value;
        left = null;
        right = null;
    }
}

class GfG {
    
    // Function to find nodes having greater value
  	// than current node.
    static void FindGreaterNodes(Node root, Node curr, 
                                 Dictionary<Node, int> map) {
        if (root == null) return;

        // if value is greater than node, then increment
        // it in the map
        if (root.data > curr.data)
            map[curr] += root.data;

        FindGreaterNodes(root.left, curr, map);
        FindGreaterNodes(root.right, curr, map);
    }

    static void TransformToGreaterSumTree(Node curr, Node root, 
                                          Dictionary<Node, int> map) {
        if (curr == null) {
            return;
        }

        // Find all nodes greater than
      	// current node
        map[curr] = 0;
        FindGreaterNodes(root, curr, map);

        // Recursively check for left and right subtree.
        TransformToGreaterSumTree(curr.left, root, map);
        TransformToGreaterSumTree(curr.right, root, map);
    }

    // Function to update value of each node.
    static void PreOrderTrav(Node root, Dictionary<Node, int> map) {
        if (root == null) return;

        root.data = map.ContainsKey(root) ? map[root] : root.data;

        PreOrderTrav(root.left, map);
        PreOrderTrav(root.right, map);
    }
  
    static void TransformTree(Node root) {
        
        // map to store greater sum for each node.
        Dictionary<Node, int> map = new Dictionary<Node, int>();
        TransformToGreaterSumTree(root, root, map);

        // update the value of nodes
        PreOrderTrav(root, map);
    }

    static void Inorder(Node root) {
        if (root == null) {
            return;
        }
        Inorder(root.left);
        Console.Write(root.data + " ");
        Inorder(root.right);
    }

    static void Main(string[] args) {
        
        // Constructing the BST
        //     11
        //    /  \
        //   2    29
        //  / \   / \
        // 1   7 15  40
        //             \
        //              50
        Node root = new Node(11);
        root.left = new Node(2);
        root.right = new Node(29);
        root.left.left = new Node(1);
        root.left.right = new Node(7);
        root.right.left = new Node(15);
        root.right.right = new Node(40);
        root.right.right.right = new Node(50);

        TransformTree(root);
        Inorder(root);
    }
}

JavaScript

// JavaScript program to transform 
// a BST to sum tree
class Node {
    constructor(value) {
        this.data = value;
        this.left = null;
        this.right = null;
    }
}

// Function to find nodes having greater value 
// than current node.
function findGreaterNodes(root, curr, map) {
    if (root === null) return;

    // if value is greater than node, then increment
    // it in the map
    if (root.data > curr.data) {
        map.set(curr, (map.get(curr) || 0) + root.data);
    }

    findGreaterNodes(root.left, curr, map);
    findGreaterNodes(root.right, curr, map);
}

function transformToGreaterSumTree(curr, root, map) {
    if (curr === null) {
        return;
    }

    // Find all nodes greater than current node
    findGreaterNodes(root, curr, map);

    // Recursively check for left and right subtree.
    transformToGreaterSumTree(curr.left, root, map);
    transformToGreaterSumTree(curr.right, root, map);
}

// Function to update value of each node.
function preOrderTrav(root, map) {
    if (root === null) return;

    root.data = map.has(root) ? map.get(root) : 0;

    preOrderTrav(root.left, map);
    preOrderTrav(root.right, map);
}

function transformTree(root) {

    // map to store greater sum for each node.
    const map = new Map();
    transformToGreaterSumTree(root, root, map);

    // update the value of nodes
    preOrderTrav(root, map);
}

function inorder(root) {
    if (root === null) {
        return;
    }
    inorder(root.left);
    console.log(root.data + " ");
    inorder(root.right);
}

// Constructing the BST
const root = new Node(11);
root.left = new Node(2);
root.right = new Node(29);
root.left.left = new Node(1);
root.left.right = new Node(7);
root.right.left = new Node(15);
root.right.right = new Node(40);
root.right.right.right = new Node(50);

transformTree(root);
inorder(root);

Output

154 152 145 134 119 90 50 0

Time Complexity: O(n^2), where n is the number of nodes in tree.
Auxiliary Space: O(n)

Note: This approach will give time limit exceeded (TLE) error.

[Expected Approach] Using Single Traversal - O(n) Time and O(n) Space

The idea is to traverse the tree in reverse in-order (right -> root -> left) while keeping a running sum of all previously visited nodes. The value of each node is updated to this running sum, which ensure that each node contains the sum of all nodes greater than it.

Below is the implementation of the above approach:

C++

// C++ program to transform a BST to sum tree

#include <bits/stdc++.h>
using namespace std;

class Node {
public:
    int data;
    Node* left;
    Node* right;

    Node(int value) {
        data = value;
        left = nullptr;
        right = nullptr;
    }
};

void transformToGreaterSumTree(Node* root, int& sum) {
    if (root == nullptr) {
        return;
    }

    // Traverse the right subtree first (larger values)
    transformToGreaterSumTree(root->right, sum);

    // Update the sum and the current node's value
    sum += root->data;
    root->data = sum - root->data;

    // Traverse the left subtree (smaller values)
    transformToGreaterSumTree(root->left, sum);
}

void transformTree(Node* root) {
  
  	// Initialize the cumulative sum
    int sum = 0; 
    transformToGreaterSumTree(root, sum);
}

void inorder(Node* root) {
    if (root == nullptr) {
        return;
    }
    inorder(root->left);
    cout << root->data << " ";
    inorder(root->right);
}

int main() {

    // Constructing the BST
    //     11
    //    /  \
    //   2    29
    //  / \   / \
    // 1   7 15  40
    //             \
    //              50

    Node* root = new Node(11);
    root->left = new Node(2);
    root->right = new Node(29);
    root->left->left = new Node(1);
    root->left->right = new Node(7);
    root->right->left = new Node(15);
    root->right->right = new Node(40);
    root->right->right->right = new Node(50);

    transformTree(root);
    inorder(root);

    return 0;
}

// C program to transform a BST 
// to sum tree

#include <stdio.h>
#include <stdlib.h>

struct Node {
    int data;
    struct Node* left;
    struct Node* right;
};

void transformToGreaterSumTree(struct Node* root, int* sum) {
    if (root == NULL) {
        return;
    }

    // Traverse the right subtree first (larger values)
    transformToGreaterSumTree(root->right, sum);

    // Update the sum and the current node's value
    *sum += root->data;
    root->data = *sum - root->data;

    // Traverse the left subtree (smaller values)
    transformToGreaterSumTree(root->left, sum);
}

void transformTree(struct Node* root) {
  
  	// Initialize the cumulative sum
    int sum = 0; 
    transformToGreaterSumTree(root, &sum);
}

void inorder(struct Node* root) {
    if (root == NULL) {
        return;
    }
    inorder(root->left);
    printf("%d ", root->data);
    inorder(root->right);
}

struct Node* createNode(int data) {
    struct Node* node = 
      (struct Node*)malloc(sizeof(struct Node));
    node->data = data;
    node->left = NULL;
    node->right = NULL;
    return node;
}

int main() {
  
    // Constructing the BST
    //     11
    //    /  \
    //   2    29
    //  / \   / \
    // 1   7 15  40
    //             \
    //              50

    struct Node* root = createNode(11);
    root->left = createNode(2);
    root->right = createNode(29);
    root->left->left = createNode(1);
    root->left->right = createNode(7);
    root->right->left = createNode(15);
    root->right->right = createNode(40);
    root->right->right->right = createNode(50);

    transformTree(root);
    inorder(root);
    return 0;
}

Java

// Java program to transform a 
// BST to sum tree

class Node {
    int data;
    Node left, right;

    Node(int value) {
        data = value;
        left = right = null;
    }
}

class GfG {

    static void transformToGreaterSumTree(Node root, int[] sum) {
        if (root == null) {
            return;
        }

        // Traverse the right subtree first (larger values)
        transformToGreaterSumTree(root.right, sum);

        // Update the sum and the current node's value
        sum[0] += root.data;
        root.data = sum[0] - root.data;

        // Traverse the left subtree (smaller values)
        transformToGreaterSumTree(root.left, sum);
    }

    static void transformTree(Node root) {
      
      	// Initialize the cumulative sum
        int[] sum = {0}; 
        transformToGreaterSumTree(root, sum);
    }

    static void inorder(Node root) {
        if (root == null) {
            return;
        }
        inorder(root.left);
        System.out.print(root.data + " ");
        inorder(root.right);
    }

    public static void main(String[] args) {
      
        // Constructing the BST
        //     11
        //    /  \
        //   2    29
        //  / \   / \
        // 1   7 15  40
        //             \
        //              50

        Node root = new Node(11);
        root.left = new Node(2);
        root.right = new Node(29);
        root.left.left = new Node(1);
        root.left.right = new Node(7);
        root.right.left = new Node(15);
        root.right.right = new Node(40);
        root.right.right.right = new Node(50);

        transformTree(root);
        inorder(root);
    }
}

Python

# Python program to transform a BST to sum tree

class Node:
    def __init__(self, value):
        self.data = value
        self.left = None
        self.right = None

def transformToGreaterSumTree(root, sum):
    if root is None:
        return

    # Traverse the right subtree first (larger values)
    transformToGreaterSumTree(root.right, sum)

    # Update the sum and the current node's value
    sum[0] += root.data
    root.data = sum[0] - root.data

    # Traverse the left subtree (smaller values)
    transformToGreaterSumTree(root.left, sum)

def transformTree(root):
  
  	# Initialize the cumulative sum
    sum = [0]  
    transformToGreaterSumTree(root, sum)

def inorder(root):
    if root is None:
        return
    inorder(root.left)
    print(root.data, end=" ")
    inorder(root.right)

if __name__ == "__main__":
  
    # Constructing the BST
    #     11
    #    /  \
    #   2    29
    #  / \   / \
    # 1   7 15  40
    #             \
    #              50

    root = Node(11)
    root.left = Node(2)
    root.right = Node(29)
    root.left.left = Node(1)
    root.left.right = Node(7)
    root.right.left = Node(15)
    root.right.right = Node(40)
    root.right.right.right = Node(50)

    transformTree(root)
    inorder(root)

// C# program to transform a BST to sum tree

using System;

class Node {
    public int data;
    public Node left, right;

    public Node(int value) {
        data = value;
        left = right = null;
    }
}

class GfG {
  
    static void transformToGreaterSumTree(Node root, ref int sum) {
        if (root == null) {
            return;
        }

        // Traverse the right subtree first (larger values)
        transformToGreaterSumTree(root.right, ref sum);

        // Update the sum and the current node's value
        sum += root.data;
        root.data = sum - root.data;

        // Traverse the left subtree (smaller values)
        transformToGreaterSumTree(root.left, ref sum);
    }

    static void transformTree(Node root) {
      
      	// Initialize the cumulative sum
        int sum = 0; 
        transformToGreaterSumTree(root, ref sum);
    }

    static void inorder(Node root) {
        if (root == null) {
            return;
        }
        inorder(root.left);
        Console.Write(root.data + " ");
        inorder(root.right);
    }

    static void Main() {
      
        // Constructing the BST
        //     11
        //    /  \
        //   2    29
        //  / \   / \
        // 1   7 15  40
        //             \
        //              50

        Node root = new Node(11);
        root.left = new Node(2);
        root.right = new Node(29);
        root.left.left = new Node(1);
        root.left.right = new Node(7);
        root.right.left = new Node(15);
        root.right.right = new Node(40);
        root.right.right.right = new Node(50);

        transformTree(root);
        inorder(root);
    }
}

JavaScript

// JavaScript program to transform a
// BST to sum tree

class Node {
    constructor(value) {
        this.data = value;
        this.left = null;
        this.right = null;
    }
}

function transformToGreaterSumTree(root, sum) {
    if (root === null) {
        return;
    }

    // Traverse the right subtree first (larger values)
    transformToGreaterSumTree(root.right, sum);

    // Update the sum and the current node's value
    sum[0] += root.data;
    root.data = sum[0] - root.data;

    // Traverse the left subtree (smaller values)
    transformToGreaterSumTree(root.left, sum);
}

function transformTree(root) {
    let sum = [0]; // Initialize the cumulative sum
    transformToGreaterSumTree(root, sum);
}

// Function to perform in-order traversal (for testing)
function inorder(root) {
    if (root === null) {
        return;
    }
    inorder(root.left);
    console.log(root.data + " ");
    inorder(root.right);
}

// Constructing the BST
//     11
//    /  \
//   2    29
//  / \   / \
// 1   7 15  40
//             \
//              50

let root = new Node(11);
root.left = new Node(2);
root.right = new Node(29);
root.left.left = new Node(1);
root.left.right = new Node(7);
root.right.left = new Node(15);
root.right.right = new Node(40);
root.right.right.right = new Node(50);

transformTree(root);
inorder(root);