## DEV Community is a community of 623,823 amazing developers

We're a place where coders share, stay up-to-date and grow their careers. # Solution: Convert BST to Greater Tree

This is part of a series of Leetcode solution explanations (index). If you liked this solution or found it useful, please like this post and/or upvote my solution post on Leetcode's forums.

#### Leetcode Problem #538 (Medium): Convert BST to Greater Tree

Description:

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 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.

Examples:

Example 1:
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]
Visual: Example 2:
Input: root = [0,null,1]
Output: [1,null,1]
Example 3:
Input: root = [1,0,2]
Output: [3,3,2]
Example 4:
Input: root = [3,2,4,1]
Output: [7,9,4,10]

Constraints:

• The number of nodes in the tree is in the range `[0, 104]`.
• `-10^4 <= Node.val <= 10^4`
• All the values in the tree are unique.
• `root` is guaranteed to be a valid binary search tree.

Idea:

The simple solution here is just to recursively traverse the BST in reverse order and convert each node's value to the cumulative sum value of all the nodes already visited.

Implementation:

A recursive inorder BST traversal is extremely easy. Based on the nature of a BST, if you always go left first whenever possible, then deal with the current node, then go right, you'll end up dealing with the nodes in their sorted order.

In this instance, however, we can shorten the code by just doing the reverse: right first, then current, then left.

Javascript Code:

The best result for the code below is 104ms / 37.6MB (beats 95%).

``````var convertBST = function(root) {
let sum = 0
const trav = node => {
if (!node) return
trav(node.right)
sum += node.val, node.val = sum
trav(node.left)
}
trav(root)
return root
};
``````

## Discussion (0) 