代码随想录训练营第23天 | 669. 修剪二叉搜索树、108.将有序数组转换为二叉搜索树、538.把二叉搜索树转换为累加树

669. 修剪二叉搜索树 

题目链接：修剪二叉搜索树

解法：

递归：递归函数需要有返回值，更方便，可以通过递归函数的返回值来移除节点。

如果root（当前节点）的元素小于low的数值，那么应该递归右子树，并返回右子树符合条件的头结点。如果root(当前节点)的元素大于high的，那么应该递归左子树，并返回左子树符合条件的头结点。接下来要将下一层处理完左子树的结果赋给root->left，处理完右子树的结果赋给root->right。

迭代法：不需要用到栈和队列，因为是有序的。在剪枝的时候，可以分为三步：

• 将root移动到[L, R] 范围内，注意是左闭右闭区间
• 剪枝左子树
• 剪枝右子树

迭代法比较麻烦，自己写还真写不出来。

边界条件：

时间复杂度：

空间复杂度：

# 递归法
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def trimBST(self, root, low, high):
        """
        :type root: TreeNode
        :type low: int
        :type high: int
        :rtype: TreeNode
        """
        if not root:
            return None

        if root.val > high:
            return self.trimBST(root.left, low, high)
        elif root.val < low:
            return self.trimBST(root.right, low, high)
        else:
            root.left = self.trimBST(root.left, low, high)
            root.right = self.trimBST(root.right, low, high) 
            return root

# 迭代法
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def trimBST(self, root, low, high):
        """
        :type root: TreeNode
        :type low: int
        :type high: int
        :rtype: TreeNode
        """
        if not root:
            return root
        
        # 把root移动到值在区间内
        while root and (root.val < low or root.val > high):
            if root.val < low:
                root = root.right
            if root.val > high:
                root = root.left
        # 对左子树减枝
        cur = root
        while cur:
            # 不断减枝，直到值在区间内
            while cur.left and cur.left.val < low:
                cur.left = cur.left.right
            # 更新cur节点，继续减枝，直到空节点
            cur = cur.left
        # 对右子树减枝
        cur = root
        while cur:
            while cur.right and cur.right.val > high:
                cur.right = cur.right.left
            cur = cur.right
        return root

108.将有序数组转换为二叉搜索树 

题目链接：将有序数组转化为二叉树搜索树

解法：

一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1。

这个题本质就是寻找分割点，分割点作为当前节点，然后递归左区间和右区间。分割点就是数组中间位置的节点。如果数组的长度是偶数，那么中间节点取左或右的都行，构造的二叉树都满足条件。

递归法：实现细节上，如果使用left和right的来原地取数，可以不用重新定义左右区间数组，而是用下标来操作原数组。但是要注意：int mid = left + ((right - left) / 2)，要这么写，防止因为left和right过大，导致越界。我自己实现的方式是不用left和right，也是原地取数。

迭代法：迭代法非常麻烦，不直观，不适合。

边界条件：无

时间复杂度：

空间复杂度：

# 递归法
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def sortedArrayToBST(self, nums):
        """
        :type nums: List[int]
        :rtype: TreeNode
        """
        if not nums:
            return None
        if len(nums) == 1:
            return TreeNode(nums[0])
        mid = len(nums) // 2
        root = TreeNode(nums[mid])
        root.left = self.sortedArrayToBST(nums[:mid])
        root.right = self.sortedArrayToBST(nums[mid+1:])
        return root

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

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

解法：

从树中可以看出累加的顺序是右中左，所以我们需要反中序遍历这个二叉树，然后顺序累加就可以了。

需要一个pre指针记录当前遍历节点cur的前一个节点，这样才方便做累加。要右中左来遍历二叉树， 中节点的处理逻辑就是让cur的数值加上前一个节点的数值，并且更新pre指针。

递归法和迭代法，都是用中序遍历的模版，然后改为右中左来处理即可。

边界条件：

时间复杂度：

空间复杂度：

# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def convertBST(self, root):
        """
        :type root: TreeNode
        :rtype: TreeNode
        """
        # pre指针记录上一步的值
        self.pre = 0
        self.traversal(root)
        return root

    def traversal(self, root):
        # 直接修改node的值，不用返回
        if not root:
            return
        # 按右中左的顺序进行处理
        self.traversal(root.right)
        root.val += self.pre
        self.pre = root.val
        self.traversal(root.left)

# 迭代法
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def convertBST(self, root):
        """
        :type root: TreeNode
        :rtype: TreeNode
        """
        if not root:
            return None
        stack = []
        cur = root
        pre = 0
        while cur or stack:
            if cur:
                stack.append(cur)
                cur = cur.right
            else:
                cur = stack.pop()
                cur.val += pre
                pre = cur.val
                cur = cur.left
        return root