LeetCode-538. Convert BST to Greater Tree

538. Convert BST to Greater Tree

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

Example:

Input: The root of a Binary Search Tree like this:
              5
            /   \
           2     13

Output: The root of a Greater Tree like this:
             18
            /   \
          20     13

题解：

如果知道二叉搜索树的性质的话，应该还是比较容易的。

遍历二叉搜索树，先遍历最右子树，就一定是节点值最大的，就保持原值（+sum，初始值为0）并记录sum。

返回父节点把父节点就加上sum的值，并更新sum的值。

然后遍历父节点的左子树，用递归就很好实现了。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    int sum = 0;
    
    public TreeNode convertBST(TreeNode root) {
        convert(root);
        return root;
    }
    
    public void convert(TreeNode t) {
        if (t == null) return;
        convert(t.right);
        t.val += sum;
        sum = t.val;
        convert(t.left);
    }
}

当然也可以不使用递归，用stack来记录已经遍历的节点，遍历完成就出站，都是右子树优先

class Solution {
    public TreeNode convertBST(TreeNode root) {
        int sum = 0;
        TreeNode node = root;
        Stack<TreeNode> stack = new Stack<TreeNode>();

        while (!stack.isEmpty() || node != null) {
            /* push all nodes up to (and including) this subtree's maximum on
             * the stack. */
            while (node != null) {
                stack.add(node);
                node = node.right;
            }

            node = stack.pop();
            sum += node.val;
            node.val = sum;

            /* all nodes with values between the current and its parent lie in
             * the left subtree. */
            node = node.left;
        }

        return root;
    }
}