Convert BST to Greater Tree

Convert BST to Greater Tree - Problem

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

As a reminder, a binary search tree is a tree that satisfies these constraints:

The left subtree of a node contains only nodes with keys less than the node's key.
The right subtree of a node contains only nodes with keys greater than the node's key.
Both the left and right subtrees must also be binary search trees.

Input & Output

Example 1 — Basic 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: For each node, add sum of all greater values. Node 4 becomes 4+5+6+7+8=30, node 1 becomes 1+2+3+4+5+6+7+8=36, etc.

Example 2 — Smaller BST

$ Input: root = [0,null,1]

› Output: [1,null,1]

💡 Note: Node 0 becomes 0+1=1 (sum of greater values), node 1 stays 1 (no greater values exist)

Example 3 — Single Node

$ Input: root = [1]

› Output: [1]

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

Constraints

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

Visualization

Tap to expand

Asked in

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

The key insight is to use reverse in-order traversal (right-root-left) which naturally processes BST nodes from largest to smallest. This allows us to maintain a running sum of all previously visited (larger) nodes and update each current node efficiently. Best approach is Reverse In-Order DFS with Time: O(n), Space: O(h).

Common Approaches

✓ Brute Force - For Each Node Calculate Sum

⏱️ Time: O(n²) Space: O(h)

Visit each node in the tree and for every node, perform a separate traversal to find all nodes with greater values and sum them up. Then add this sum to the current node's value.

Reverse In-Order DFS

⏱️ Time: O(n) Space: O(h)

Traverse the BST in reverse in-order (right subtree, root, left subtree) while maintaining a running sum. This naturally processes nodes from largest to smallest value, allowing us to update each node with the accumulated sum of all previously visited (larger) nodes.

Brute Force - For Each Node Calculate Sum — Algorithm Steps

Step 1: For each node in the tree
Step 2: Traverse entire tree to find nodes with greater values
Step 3: Sum those greater values and add to current node

Visualization

Tap to expand

Step-by-Step Walkthrough

For Node 4

Find all nodes > 4: {5,6,7,8}, sum = 26

For Node 1

Find all nodes > 1: {2,3,4,5,6,7,8}, sum = 35

Update Values

Add sums: 4→30, 1→36, etc.

Code -

solution.c — C

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

#define MAX_NODES 10000
#define MAX_INPUT 100000

struct TreeNode {
    int val;
    struct TreeNode* left;
    struct TreeNode* right;
};

struct NodeMap {
    struct TreeNode* node;
    int originalVal;
};

static struct NodeMap originalValues[MAX_NODES];
static int mapSize = 0;

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

void storeOriginal(struct TreeNode* node) {
    if (!node) return;
    originalValues[mapSize].node = node;
    originalValues[mapSize].originalVal = node->val;
    mapSize++;
    storeOriginal(node->left);
    storeOriginal(node->right);
}

int getOriginalValue(struct TreeNode* node) {
    for (int i = 0; i < mapSize; i++) {
        if (originalValues[i].node == node) {
            return originalValues[i].originalVal;
        }
    }
    return node->val;
}

int getSumGreater(struct TreeNode* node, int targetVal) {
    if (!node) return 0;
    int total = 0;
    int originalVal = getOriginalValue(node);
    if (originalVal > targetVal) {
        total += originalVal;
    }
    total += getSumGreater(node->left, targetVal);
    total += getSumGreater(node->right, targetVal);
    return total;
}

void convertNode(struct TreeNode* node, struct TreeNode* root) {
    if (!node) return;
    int originalVal = getOriginalValue(node);
    int sumGreater = getSumGreater(root, originalVal);
    node->val = originalVal + sumGreater;
    convertNode(node->left, root);
    convertNode(node->right, root);
}

struct TreeNode* solution(struct TreeNode* root) {
    if (!root) return NULL;
    mapSize = 0;
    storeOriginal(root);
    convertNode(root, root);
    return root;
}

struct TreeNode* buildTree(int* arr, int size) {
    if (size == 0 || arr[0] == -1) return NULL;
    
    struct TreeNode* root = createNode(arr[0]);
    struct TreeNode* queue[MAX_NODES];
    int front = 0, rear = 0;
    queue[rear++] = root;
    
    int i = 1;
    while (front < rear && i < size) {
        struct TreeNode* node = queue[front++];
        
        if (i < size && arr[i] != -1) {
            node->left = createNode(arr[i]);
            queue[rear++] = node->left;
        }
        i++;
        
        if (i < size && arr[i] != -1) {
            node->right = createNode(arr[i]);
            queue[rear++] = node->right;
        }
        i++;
    }
    
    return root;
}

void treeToArray(struct TreeNode* root, int* result, int* size) {
    if (!root) {
        *size = 0;
        return;
    }
    
    struct TreeNode* queue[MAX_NODES];
    int front = 0, rear = 0;
    queue[rear++] = root;
    
    *size = 0;
    while (front < rear) {
        struct TreeNode* node = queue[front++];
        
        if (node) {
            result[(*size)++] = node->val;
            queue[rear++] = node->left;
            queue[rear++] = node->right;
        } else {
            result[(*size)++] = -1; // Use -1 for null
        }
    }
    
    // Remove trailing nulls
    while (*size > 0 && result[*size - 1] == -1) {
        (*size)--;
    }
}

int parseArray(char* input, int* arr) {
    int size = 0;
    char* ptr = input;
    
    // Skip to '['
    while (*ptr && *ptr != '[') ptr++;
    if (!*ptr) return 0;
    ptr++;
    
    while (*ptr) {
        // Skip whitespace and commas
        while (*ptr && (*ptr == ' ' || *ptr == ',' || *ptr == '\n' || *ptr == '\t')) ptr++;
        
        if (*ptr == ']') break;
        
        if (strncmp(ptr, "null", 4) == 0) {
            arr[size++] = -1;
            ptr += 4;
        } else if (isdigit(*ptr) || *ptr == '-') {
            long val = strtol(ptr, &ptr, 10);
            arr[size++] = (int)val;
        } else {
            ptr++;
        }
    }
    
    return size;
}

int main() {
    char input[MAX_INPUT];
    if (!fgets(input, sizeof(input), stdin)) {
        printf("[]\n");
        return 0;
    }
    
    int arr[MAX_NODES];
    int size = parseArray(input, arr);
    
    if (size == 0) {
        printf("[]\n");
        return 0;
    }
    
    struct TreeNode* root = buildTree(arr, size);
    struct TreeNode* result_root = solution(root);
    
    int result[MAX_NODES];
    int resultSize;
    treeToArray(result_root, result, &resultSize);
    
    printf("[");
    for (int i = 0; i < resultSize; i++) {
        if (i > 0) printf(",");
        if (result[i] == -1) {
            printf("null");
        } else {
            printf("%d", result[i]);
        }
    }
    printf("]\n");
    
    return 0;
}

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

125.0K Views

Medium Frequency

~15 min Avg. Time

2.8K 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - For Each Node Calculate Sum — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler