##### Welcome to Subscribe On Youtube

Formatted question description: https://leetcode.ca/all/1038.html

# 1038. Binary Search Tree to Greater Sum Tree (Medium)

Given the root of a binary search tree with distinct values, modify it so that every node has a new value equal to the sum of the values of the original tree that are greater than or equal to node.val.

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.

Example 1:

Input: [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:

1. The number of nodes in the tree is between 1 and 100.
2. Each node will have value between 0 and 100.
3. The given tree is a binary search tree.

Companies:
Amazon

Related Topics:
Binary Search Tree

## Solution 1.

// OJ: https://leetcode.com/problems/binary-search-tree-to-greater-sum-tree/
// Time: O(N)
// Space: O(N)
class Solution {
private:
int sum = 0;
public:
TreeNode* bstToGst(TreeNode* root) {
if (!root) return NULL;
bstToGst(root->right);
root->val = (sum += root->val);
bstToGst(root->left);
return root;
}
};

• /**
* Definition for a binary tree node.
* public class TreeNode {
*     int val;
*     TreeNode left;
*     TreeNode right;
*     TreeNode(int x) { val = x; }
* }
*/
class Solution {
public TreeNode bstToGst(TreeNode root) {
if (root == null)
return root;
int prevVal = 0;
Stack<TreeNode> stack = new Stack<TreeNode>();
TreeNode node = root;
while (!stack.isEmpty() || node != null) {
while (node != null) {
stack.push(node);
node = node.right;
}
TreeNode visitNode = stack.pop();
visitNode.val += prevVal;
prevVal = visitNode.val;
node = visitNode.left;
}
return root;
}
}

############

/**
* Definition for a binary tree node.
* public class TreeNode {
*     int val;
*     TreeNode left;
*     TreeNode right;
*     TreeNode() {}
*     TreeNode(int val) { this.val = val; }
*     TreeNode(int val, TreeNode left, TreeNode right) {
*         this.val = val;
*         this.left = left;
*         this.right = right;
*     }
* }
*/
class Solution {
public TreeNode bstToGst(TreeNode root) {
int s = 0;
TreeNode node = root;
while (root != null) {
if (root.right == null) {
s += root.val;
root.val = s;
root = root.left;
} else {
TreeNode next = root.right;
while (next.left != null && next.left != root) {
next = next.left;
}
if (next.left == null) {
next.left = root;
root = root.right;
} else {
s += root.val;
root.val = s;
next.left = null;
root = root.left;
}
}
}
return node;
}
}

• // OJ: https://leetcode.com/problems/binary-search-tree-to-greater-sum-tree/
// Time: O(N)
// Space: O(H)
class Solution {
int sum = 0;
public:
TreeNode* bstToGst(TreeNode* root) {
if (!root) return nullptr;
bstToGst(root->right);
root->val = (sum += root->val);
bstToGst(root->left);
return root;
}
};

• # Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
def bstToGst(self, root: TreeNode) -> TreeNode:
s = 0
node = root
while root:
if root.right is None:
s += root.val
root.val = s
root = root.left
else:
next = root.right
while next.left and next.left != root:
next = next.left
if next.left is None:
next.left = root
root = root.right
else:
s += root.val
root.val = s
next.left = None
root = root.left
return node

############

# 1038. Binary Search Tree to Greater Sum Tree
# https://leetcode.com/problems/binary-search-tree-to-greater-sum-tree/

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
curr = 0
def bstToGst(self, root: TreeNode) -> TreeNode:
if root.right: self.bstToGst(root.right)
root.val = self.curr = self.curr + root.val
if root.left: self.bstToGst(root.left)

return root


• /**
* Definition for a binary tree node.
* type TreeNode struct {
*     Val int
*     Left *TreeNode
*     Right *TreeNode
* }
*/
func bstToGst(root *TreeNode) *TreeNode {
s := 0
node := root
for root != nil {
if root.Right == nil {
s += root.Val
root.Val = s
root = root.Left
} else {
next := root.Right
for next.Left != nil && next.Left != root {
next = next.Left
}
if next.Left == nil {
next.Left = root
root = root.Right
} else {
s += root.Val
root.Val = s
next.Left = nil
root = root.Left
}
}
}
return node
}

• /**
* Definition for a binary tree node.
* class TreeNode {
*     val: number
*     left: TreeNode | null
*     right: TreeNode | null
*     constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
*         this.val = (val===undefined ? 0 : val)
*         this.left = (left===undefined ? null : left)
*         this.right = (right===undefined ? null : right)
*     }
* }
*/

function bstToGst(root: TreeNode | null): TreeNode | null {
let cur = root;
let sum = 0;
while (cur != null) {
const { val, left, right } = cur;
if (right == null) {
sum += val;
cur.val = sum;
cur = left;
} else {
let next = right;
while (next.left != null && next.left != cur) {
next = next.left;
}
if (next.left == null) {
next.left = cur;
cur = right;
} else {
next.left = null;
sum += val;
cur.val = sum;
cur = left;
}
}
}
return root;
}


• /**
* Definition for a binary tree node.
* function TreeNode(val, left, right) {
*     this.val = (val===undefined ? 0 : val)
*     this.left = (left===undefined ? null : left)
*     this.right = (right===undefined ? null : right)
* }
*/
/**
* @param {TreeNode} root
* @return {TreeNode}
*/
var bstToGst = function (root) {
let s = 0;
function dfs(root) {
if (!root) {
return;
}
dfs(root.right);
s += root.val;
root.val = s;
dfs(root.left);
}
dfs(root);
return root;
};


• // Definition for a binary tree node.
// #[derive(Debug, PartialEq, Eq)]
// pub struct TreeNode {
//   pub val: i32,
//   pub left: Option<Rc<RefCell<TreeNode>>>,
//   pub right: Option<Rc<RefCell<TreeNode>>>,
// }
//
// impl TreeNode {
//   #[inline]
//   pub fn new(val: i32) -> Self {
//     TreeNode {
//       val,
//       left: None,
//       right: None
//     }
//   }
// }
use std::rc::Rc;
use std::cell::RefCell;
impl Solution {
fn dfs(root: &mut Option<Rc<RefCell<TreeNode>>>, mut sum: i32) -> i32 {
if let Some(node) = root {
let mut node = node.as_ref().borrow_mut();
sum = Self::dfs(&mut node.right, sum) + node.val;
node.val = sum;
sum = Self::dfs(&mut node.left, sum);
}
sum
}

pub fn bst_to_gst(mut root: Option<Rc<RefCell<TreeNode>>>) -> Option<Rc<RefCell<TreeNode>>> {
Self::dfs(&mut root, 0);
root
}
}