1038. Binary Search Tree to Greater Sum Tree, 这个方法好！

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]

 

Constraints:

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

一开始的思路，没想到原树改造，所以有了下面的思路。

class Solution {
public:
    TreeNode* bstToGst(TreeNode* root) {
        vector<int> helper;
        midSearch(root, helper);

        TreeNode* res = nullptr;
        sumCopy(root, res, helper);

        return res;
    }
    private:
    void midSearch(TreeNode* root, vector<int>& helper)
    {
        if(root == nullptr)
            return;
        midSearch(root->left, helper);
        helper.push_back(root->val);
        midSearch(root->right, helper);
    }
    void sumCopy(TreeNode* root, TreeNode* &res, vector<int>& helper)
    {
        if(root == nullptr)
            return;

        res = new TreeNode();
        int oldV = root->val;
        int pos = findInHelper(helper, oldV);

        int newV = std::accumulate(helper.begin() + pos, helper.end(), 0);
        res->val = newV;

        sumCopy(root->left, res->left, helper);
        sumCopy(root->right, res->right, helper);
    }
    int findInHelper(vector<int>& helper, int v)
    {
        int start = 0;
        int end = helper.size() - 1;
        while(start <= end)
        {

            int mid = (end + start)/2;

            if(helper[mid] == v)
                return mid;
            if(helper[mid] < v)
                start = mid + 1;
            else
                end = mid - 1;
        }
        return -1;
    }
};

运行结果还行，

Runtime: 0 ms, faster than 100.00% of C++ online submissions for Binary Search Tree to Greater Sum Tree.

Memory Usage: 8 MB, less than 5.36% of C++ online submissions for Binary Search Tree to Greater Sum Tree.

其实自己都觉得繁琐，用了中序遍历，还用了2分查找，算是用全了。

后来反馈别人的思路，喜欢这一个。

想想也是，新的节点值，就是从右边开始遍历的积累数值啊，咋没想到呢。

class Solution {
public:
    
    void traversal(TreeNode* node)       // Reverse inorder traversal to traverse BST in descending order
    {
        if(!node)
            return;
        traversal(node -> right);
        sum += node -> val;
        node -> val = sum;
        traversal(node -> left);
    }
    
    TreeNode* bstToGst(TreeNode* root) 
    {
        traversal(root);
        return root;
    }
private:
    int sum;
};