538. bst遍历求累加和

538. Convert BST to Greater Tree

bst遍历求累加和

复杂度

• 时间复杂度是O(N)，准确来说是O(H+N)->O(2N)，H是树高，因为在开始遍历节点之前，必须到达叶子节点。
• 空间复杂度是O(H)，入栈节点最高等于H

v1 回溯

/*
* Runtime: 3 ms, faster than 93.00% of Java online submissions for Convert BST to Greater Tree.
* Memory Usage: 39.2 MB, less than 67.29% of Java online submissions for Convert BST to Greater Tree.
* */
class Solution {
    public TreeNode convertBST(TreeNode root) {
        System.out.println(bstToGreaterTree(root,0));
        return root;
    }

    private int bstToGreaterTree(TreeNode root, int parSum) {
        if (root == null) return parSum;
        int rightSum = bstToGreaterTree(root.right, parSum);
        root.val += rightSum;
        int leftSum = bstToGreaterTree(root.left, root.val);
        return leftSum;
    }

}

v1.1 全局变量

这是最好写的，而且最快。

/*
* 全局变量版本，更好写
* Runtime: 0 ms, faster than 100.00% of Java online submissions for Convert BST to Greater Tree.
* Memory Usage: 39.2 MB, less than 67.29% of Java online submissions for Convert BST to Greater Tree.
* */
public class SolutionV1_1 {
    private int sum = 0;
    public TreeNode convertBST(TreeNode root) {
        bstToGreaterTree(root);
        return root;
    }

    private void bstToGreaterTree(TreeNode root) {
        if (root == null) return;
        bstToGreaterTree(root.right);
        sum += root.val;
        root.val = sum;
        bstToGreaterTree(root.left);
        return;
    }
}

v2 迭代实现

递归的效率已经非常高了，不管是空间还是时间上。

/*
* 迭代版本
* Runtime: 2 ms, faster than 17.80% of Java online submissions for Convert BST to Greater Tree.
* Memory Usage: 39.2 MB, less than 79.53% of Java online submissions for Convert BST to Greater Tree.
* */
public class SolutionV2 {
    public TreeNode convertBST(TreeNode root) {
        Stack<TreeNode> stack = new Stack<>();
        TreeNode r = root;
        int sum = 0;
        while (true) {
            while (root != null) {
                stack.push(root);
                root = root.right;
            }
            if (stack.isEmpty()) return r;
            root = stack.peek();
            stack.pop();
            sum += root.val;
            root.val = sum;
            root = root.left;
        }
    }


    public static void main(String[] args) {
        String input = "4,1,6,0,2,5,7,null,null,null,3,null,null,null,8";
        TreeNode inputRoot = BinTreeTools.levRebuild(input);
        BinTreeTools.trav(inputRoot, "lev");
        TreeNode root = new SolutionV2().convertBST(inputRoot);
        BinTreeTools.trav(root, "lev");
    }
}