day21 代码随想录 | 修剪二叉搜索树 有序数组转为二叉搜索树 二叉搜索树转换为累加树

修剪二叉搜索树

给你二叉搜索树的根节点 root ，同时给定最小边界low 和最大边界 high。通过修剪二叉搜索树，使得所有节点的值在[low, high]中。修剪树 不应该 改变保留在树中的元素的相对结构 (即，如果没有被移除，原有的父代子代关系都应当保留)。 可以证明，存在 唯一的答案 。

所以结果应当返回修剪好的二叉搜索树的新的根节点。注意，根节点可能会根据给定的边界发生改变。

这个题，我一来就想到与删除二叉搜索树的联系！都是删除节点，只不过删除二叉搜索树是删除某一个节点，而这个题是有判断条件的！节点的值要在某个区间内。

判断条件就是 node.val > low and node.val < high。

那么我们就在这个条件下左单层递归。但是，你会发现，node.val < low和node.val > high两个条件分别对应的操作是不一样的。

当node.val < low的时候，由于是二叉搜索树,那么它的左子树一定小于low，右子树可能大于也可能小于low. 就像判断删除一个节点类似，我们可以对node的形式进行讨论

1. 如果node是叶子节点，那直接删除，对应的是直接return None

2. 如果node的左子树不为空，右子树为空，对应的也是直接返回None

3. 如果node的右子树不为空，可能我们第一反应是直接返回右子树！但是，这样是错误的。不能直接返回右子树，因为你不能保证右子树一定所有的值的node都满足大于low，因此，需要对右子树进行递归

同样，在node.val > high的时候

1. 如果node是叶子节点，那直接删除，对应的是直接return None

2. 如果node的右子树不为空，左子树为空，对应的也是直接返回None

3. 如果node的左子树不为空，可能我们第一反应是直接返回左树！但是，这样是错误的。不能直接返回右子树，因为你不能保证左子树一定所有的值的node都小于low，因此，需要对左子树进行递归。

了解清楚这个逻辑后，代码就好写了

递归三部曲

1. 递归参数和返回值  参数就是 node, low, high 返回的是root

2. 递归中止条件：如果遇到空节点 返回None

3. 单层递归

   就是上面分析的逻辑

class Solution:
    def trimBST(self, root: Optional[TreeNode], low: int, high: int) -> Optional[TreeNode]:
        if not root: return None

        if root.val < low:
            if root.left is None and root.right is None:
                return None

            elif root.left is not None and root.right is None:
                return None

            else:
                root.right = self.trimBST(root.right, low, high) # 递归右子树
                return root.right


        if root.val > high:
            if root.left is None and root.right is None:
                return None

            elif root.right is not None and root.left is None:
                return None

            else:
                root.left = self.trimBST(root.left, low, high)
                return root.left

        root.left = self.trimBST(root.left, low, high)

        root.right = self.trimBST(root.right, low, high)

        return root

有序数组转为二叉搜索树 

给你一个整数数组 nums ，其中元素已经按 升序 排列，请你将其转换为一棵 平衡二叉搜索树。

这个题就是构造二叉搜索树，其实跟我们之前前序 后序构建二叉树类似，核心在于如何切分

其实思路很简单，我们已nums的中点为分割点，左边传入左子树，右边传入右子树，

中点就是根节点，按照中左右的遍历方式。就OK了

代码如下

class Solution:
    def sortedArrayToBST(self, nums: List[int]) -> Optional[TreeNode]:
        if len(nums) == 0:
            return None

        mid = int(len(nums)/2)

        root.val = TreeNode(nums[mid])

        root.left = self.sortedArrayToBST(nums[:mid])
        root.right = self.sortedArrayToBST(nums[mid+1:])

        return root

把二叉搜索树转换为累加树

给出二叉 搜索 树的根节点，该树的节点值各不相同，请你将其转换为累加树（Greater Sum Tree），使每个节点 node 的新值等于原树中大于或等于 node.val 的值之和。

我一开始题都没读懂，什么玩意，标记的是什么意思，什么又是累加。

但是我们自己看看示例图，从右下角->中间->左下角。是一个累加的趋势

那么我们就明白了，那其实就是遍历，累加和嘛。二叉搜索树本来就是一个有序。

我们再看看题目条件，每个节点 node 的新值等于原树中大于或等于 node.val 的值之和，

要大于或等于原来的树的node.val的值的和，这就说明我们累加的方向，用从大到小累计。

所有遍历方向就是右中左

代码如下

class Solution:
    def __init__(self):
        self.sum = 0
    def convertBST(self, root):
        self.sum = 0
        self.dfs(root)
        return root

    def dfs(self, root):
        if not root: return

        self.dfs(root.right) # 右
        self.sum += root.val # 累加
        root.val = self.sum # 中

        self.dfs(root.left)  # 左