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

669. 修剪二叉搜索树

自己写了一版AC了。

思路主要是先修剪左右子树，然后如果当前节点val小于low，按照搜索树的性质只能返回右子树，如果val大于high,按照搜索树的性质只能返回左子树。

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def trimBST(self, root: Optional[TreeNode], low: int, high: int) -> Optional[TreeNode]:
        if not root or (root.val < low and not root.right) or (root.val > high and not root.left):
            return None

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

        return root

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

二分法

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def sortedArrayToBST(self, nums: List[int]) -> Optional[TreeNode]:
        def helper(start, end):
            if start > end:
                return None
            mid = (end - start) // 2 + start
            node = TreeNode(nums[mid])
            node.left = helper(start, mid - 1)
            node.right = helper(mid + 1, end)
            return node
        return helper(0, len(nums) - 1)

这里迭代实现感觉用三个队列有点不清晰...

直接在队列里压入tuple即可模拟。

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

        while queue:
            node, left, right = queue.popleft()
            mid = (left + right) // 2
            node.val = nums[mid]

            if left < mid:
                node.left = TreeNode()
                queue.append((node.left, left, mid - 1))

            if mid < right:
                node.right = TreeNode()
                queue.append((node.right, mid + 1, right))

        return root

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

右-中-左， 记录pre即可。

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def __init__(self):
        self.pre = None
    def convertBST(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
        if not root:
            return None
        self.convertBST(root.right)
        if self.pre:
            root.val += self.pre.val
        self.pre = root
        self.convertBST(root.left)
        return root