代码随想录刷题第23天|669.修剪二叉搜索树，108.将有序数组转换为二叉搜索树,538.把二叉搜索树转换为累加树

669.修剪二叉搜索树

递归

# 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 root is None:
            return None
        if root.val<low:
            #寻找符合区间的节点
            return self.trimBST(root.right,low,high)
        if root.val>high:
            return self.trimBST(root.left,low,high)
        root.left=self.trimBST(root.left,low,high)#root.left接入符合条件的左孩子
        root.right=self.trimBST(root.right,low,high)
        return root

# 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], L: int, R: int) -> Optional[TreeNode]:
        #迭代法
        if not root:
            return None
        while root and (root.val<L or root.val>R):
            if root.val <L:
                root=root.right#小于L往右走
            else:
                root=root.left#大于R往左走

        cur=root

        while cur:#处理左孩子元素小于L的情况
            while cur.left and cur.left.val<L:
                cur.left=cur.left.right
            cur=cur.left
        
        cur=root

        while cur:
            while cur.right and cur.right.val>R:
                cur.right=cur.right.left
            cur=cur.right

        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]:
        #迭代法
        root=self.traversal(nums,0,len(nums)-1)
        return root
        
    def traversal(self,nums,left,right):    
        if left>right:
            return None
        
        mid=left+(right-left)//2#防止溢出
        root=TreeNode(nums[mid])
        root.left=self.traversal(nums,left,mid-1)
        root.right=self.traversal(nums,mid+1,right)
        return root

# 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]:
        if len(nums)==0:
            return None
        
        root=TreeNode(0)#初始根jiedian
        nodeQue=deque()#放遍历的节点
        leftQue=deque()#存放左区间下标
        rightQue=deque()

        nodeQue.append(root)
        leftQue.append(0)#0为左区间下标初始位置
        rightQue.append(len(nums)-1)

        while nodeQue:
            curNode=nodeQue.popleft()
            left=leftQue.popleft()
            right=rightQue.popleft()
            mid=left+(right-left)//2

            curNode.val=nums[mid]

            if left<=mid-1:
                curNode.left=TreeNode(0)
                nodeQue.append(curNode.left)
                leftQue.append(left)
                rightQue.append(mid-1)

            if right>=mid+1:
                curNode.right=TreeNode(0)
                nodeQue.append(curNode.right)
                leftQue.append(mid+1)
                rightQue.append(right)

        return root

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

# 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 convertBST(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
        self.pre=0
        self.traversal(root)
        return root
    def traversal(self,cur):
        if cur is None:
            return
        self.traversal(cur.right)
        cur.val+=self.pre
        self.pre=cur.val
        self.traversal(cur.left)

# 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 convertBST(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
        if not root:
            return root
        stack=[]
        result=[]
        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

        retrun root