Convert BST to Greater Tree - Practice Coding Problems

Convert BST to Greater Tree - Problem

Transform Your BST into a Greater Tree!

Given the root of a Binary Search Tree (BST), your task is to convert it into a Greater Tree where every node's value becomes the original value plus the sum of all values greater than it in the BST.

🌳 What's a Greater Tree?
In a Greater Tree, each node stores the sum of itself and all nodes with larger values. This creates a fascinating transformation where larger values accumulate as we move towards smaller nodes!

📝 BST Properties Reminder:
• Left subtree contains only nodes with values less than the current node
• Right subtree contains only nodes with values greater than the current node
• Both subtrees are also valid BSTs

Example: If we have nodes [2, 5, 13], then:
• Node 13 becomes 13 (no greater values)
• Node 5 becomes 5 + 13 = 18
• Node 2 becomes 2 + 5 + 13 = 20

Input & Output

example_1.py — Standard BST

$ Input: root = [4,1,6,0,2,5,7,null,null,null,3,null,null,null,8]

› Output: [30,36,21,36,35,26,15,null,null,null,33,null,null,null,8]

💡 Note: Starting with BST values [0,1,2,3,4,5,6,7,8], each node gets sum of all greater values: Node 8→8 (no greater), 7→15 (7+8), 6→21 (6+7+8), etc.

example_2.py — Simple Three Node BST

$ Input: root = [2,null,5,null,null,null,13]

› Output: [20,null,18,null,null,null,13]

💡 Note: Node 13 stays 13 (largest), Node 5 becomes 5+13=18, Node 2 becomes 2+5+13=20

example_3.py — Single Node

$ Input: root = [5]

› Output: [5]

💡 Note: A single node has no greater values, so it remains unchanged

Visualization

Tap to expand

Understanding the Visualization

Original BST

Start with a valid BST where left < root < right

Identify traversal order

Reverse in-order gives us: 13 → 5 → 2 (descending)

Transform nodes

Running sum: 13 → 18 → 20, updating each node

Final Greater Tree

Each node now contains original + sum of greater values

Key Takeaway

🎯 Key Insight: Reverse in-order traversal of a BST visits nodes in descending order, allowing us to accumulate sums efficiently in a single pass!

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n nodes, we traverse all n nodes to find greater values

⚠ Quadratic Growth

Space Complexity

O(h)

Recursion stack depth equals tree height h

✓ Linear Space

Constraints

The number of nodes in the tree is in the range [0, 10⁴]
Node values are in range [-10⁴, 10⁴]
All node values are unique
The tree is guaranteed to be a valid binary search tree

Asked in

a Amazon 15 f Facebook 12 G Google 8 ⊞ Microsoft 6

The optimal solution uses reverse in-order traversal (right-root-left) to visit nodes in descending order. By maintaining a running sum of values seen so far, we can transform each node in O(n) time with a single tree traversal. This leverages the BST property perfectly!

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (For Each Node, Traverse Entire Tree)	O(n²)	O(h)	For each node, traverse the entire tree to find and sum all greater values
Reverse In-Order Traversal (Optimal)	O(n)	O(h)	Traverse the BST in reverse in-order (right-root-left) to process nodes from largest to smallest

Brute Force (For Each Node, Traverse Entire Tree) — Algorithm Steps

For each node in the tree, initiate a separate traversal
During each traversal, find all nodes with values greater than current node
Sum all the greater values found
Add this sum to the current node's original value
Repeat for every node in the tree

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with first node

For node with value 2, scan entire tree to find values > 2

Sum greater values

Found values 5 and 13, sum = 18, so node becomes 2 + 18 = 20

Repeat for each node

Perform same process for every single node in the tree

Code -

solution.c — C

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

// Definition for a binary tree node
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
};

int findGreaterSum(struct TreeNode* node, int targetVal) {
    if (!node) return 0;
    int currentSum = node->val > targetVal ? node->val : 0;
    currentSum += findGreaterSum(node->left, targetVal);
    currentSum += findGreaterSum(node->right, targetVal);
    return currentSum;
}

void transform(struct TreeNode* node, struct TreeNode* root) {
    if (!node) return;
    int originalVal = node->val;
    int greaterSum = findGreaterSum(root, originalVal);
    node->val = originalVal + greaterSum;
    transform(node->left, root);
    transform(node->right, root);
}

struct TreeNode* convertBST(struct TreeNode* root) {
    transform(root, root);
    return root;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n nodes, we traverse all n nodes to find greater values

⚠ Quadratic Growth

Space Complexity

O(h)

Recursion stack depth equals tree height h

✓ Linear Space

Constraints

The number of nodes in the tree is in the range [0, 10⁴]
Node values are in range [-10⁴, 10⁴]
All node values are unique
The tree is guaranteed to be a valid binary search tree

125.0K Views

Medium Frequency

~15 min Avg. Time

2.9K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (For Each Node, Traverse Entire Tree) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler