二叉搜索树题目：把二叉搜索树转换为累加树

题目

标题和出处

标题：把二叉搜索树转换为累加树

出处：538. 把二叉搜索树转换为累加树

难度

4 级

题目描述

要求

给定二叉搜索树的根结点 $\text{root}$，将其转换为累加树，原二叉搜索树中的每个结点值都变成原结点值加上比该结点值大的所有结点值总和。

二叉搜索树满足下列约束条件：

• 结点的左子树仅包含值小于结点值的结点。
• 结点的右子树仅包含值大于结点值的结点。
• 左右子树也必须是二叉搜索树。

示例

示例 1：

输入：$\text{root = [4,1,6,0,2,5,7,null,null,null,3,null,null,null,8]}$
输出：$\text{[30,36,21,36,35,26,15,null,null,null,33,null,null,null,8]}$

示例 2：

输入：$\text{root = [0,null,1]}$
输出：$\text{[1,null,1]}$

数据范围

• 树中结点数目在范围 ${\text{[0, 10}}^{\text{4}}\text{]}$ 内
• ${\text{-10}}^{\text{4}}\le \text{Node.val}\le {\text{10}}^{\text{4}}$
• 树中的所有值各不相同
• $\text{root}$ 保证是有效的二叉搜索树

前言

考虑二叉搜索树的中序遍历。常规的中序遍历方法是依次遍历左子树、根结点和右子树，对于左子树和右子树使用同样的方法遍历，此时二叉搜索树的中序遍历序列是单调递增的。将中序遍历的顺序改变，依次遍历右子树、根结点和左子树，则是反向中序遍历，二叉搜索树的反向中序遍历序列是单调递减的。在反向中序遍历的过程中，对于每个结点，比该结点值大的所有结点都在该结点之前被访问。

由于对二叉搜索树反向中序遍历访问结点的顺序为结点值单调递减的顺序，因此可以通过反向中序遍历将二叉搜索树转换为累加树。反向中序遍历的过程中，维护已经访问过的结点值总和，对于访问到的每个结点，将总和加到当前结点值，则当前结点值变为该结点在累加树中对应的结点值，然后将当前结点值作为更新后的结点值总和，继续遍历其余的结点，直到遍历结束时，即可得到累加树。

解法一

思路和算法

由于二叉搜索树的反向中序遍历具有递归的性质，因此可以使用递归的方法实现中序遍历。使用递归实现反向中序遍历的做法是依次访问右子树、根结点和左子树，对于右子树和左子树使用同样的方法访问。

遍历过程中维护已经访问过的结点值总和，对于访问到的每个结点，更新结点值，并更新已经访问过的结点值总和。

代码

class Solution {
    int prev = 0;

    public TreeNode convertBST(TreeNode root) {
        if (root == null) {
            return root;
        }
        convertBST(root.right);
        root.val += prev;
        prev = root.val;
        convertBST(root.left);
        return root;
    }
}

复杂度分析

• 时间复杂度：$O(n)$，其中 $n$ 是二叉搜索树的结点数。每个结点都被访问一次。

• 空间复杂度：$O(n)$，其中 $n$ 是二叉搜索树的结点数。空间复杂度主要是递归调用的栈空间，取决于二叉搜索树的高度，最坏情况下二叉搜索树的高度是 $O(n)$。

解法二

思路和算法

使用迭代实现反向中序遍历的做法是使用栈存储结点。

遍历过程中维护已经访问过的结点值总和，对于访问到的每个结点，更新结点值，并更新已经访问过的结点值总和。

代码

class Solution {
    public TreeNode convertBST(TreeNode root) {
        int prev = 0;
        Deque<TreeNode> stack = new ArrayDeque<TreeNode>();
        TreeNode node = root;
        while (!stack.isEmpty() || node != null) {
            while (node != null) {
                stack.push(node);
                node = node.right;
            }
            node = stack.pop();
            node.val += prev;
            prev = node.val;
            node = node.left;
        }
        return root;
    }
}

复杂度分析

• 时间复杂度：$O(n)$，其中 $n$ 是二叉搜索树的结点数。每个结点都被访问一次。

• 空间复杂度：$O(n)$，其中 $n$ 是二叉搜索树的结点数。空间复杂度主要是栈空间，取决于二叉搜索树的高度，最坏情况下二叉搜索树的高度是 $O(n)$。

解法三

思路和算法

使用莫里斯遍历实现反向中序遍历时，由于遍历顺序是依次遍历右子树、根结点和左子树，因此和常规的莫里斯中序遍历的方向相反。对于每个结点，判断其右子树是否为空，如果当前结点的右子树不为空，则应该找到当前结点的后继结点，即当前结点的右子树中的最左边的结点，对后继结点执行相应的操作。

遍历过程中维护已经访问过的结点值总和，对于访问到的每个结点，更新结点值，并更新已经访问过的结点值总和。

代码

class Solution {
    public TreeNode convertBST(TreeNode root) {
        int prev = 0;
        TreeNode node = root;
        while (node != null) {
            if (node.right == null) {
                node.val += prev;
                prev = node.val;
                node = node.left;
            } else {
                TreeNode successor = node.right;
                while (successor.left != null && successor.left != node) {
                    successor = successor.left;
                }
                if (successor.left == null) {
                    successor.left = node;
                    node = node.right;
                } else {
                    successor.left = null;
                    node.val += prev;
                    prev = node.val;
                    node = node.left;
                }
            }
        }
        return root;
    }
}

复杂度分析

• 时间复杂度：$O(n)$，其中 $n$ 是二叉搜索树的结点数。使用莫里斯遍历，每个结点最多被访问两次。

• 空间复杂度：$O(1)$。