代码随想录算法训练营第二十三天

669. 修剪二叉搜索树

题目链接：修剪二叉搜索树
这个和昨天的题很像，但是要更注意二叉搜索树的特性。
首先就是如果current node是在low和high的区间里的，那么就不改变他自己，左右孩子进去递归。
如果比low还小，那么右孩子可以进去递归判断大小了，左孩子就可以都不要了。
如果比high还大，那么左孩子就可以进去递归判断大小了，右孩子就都不要了。

class Solution:
    def trimBST(self, root: Optional[TreeNode], low: int, high: int) -> Optional[TreeNode]:
        if not root:
            return root
        if root.val >= low and root.val <= high:
            root.left = self.trimBST(root.left, low, high)
            root.right = self.trimBST(root.right, low, high)
        elif root.val < low:
            if root.right:
                return self.trimBST(root.right, low, high)
            else:
                return None
        elif root.val > high:
            if root.left:
                return self.trimBST(root.left, low, high)
            else:
                return None
        return root

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

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

class Solution:
    def sortedArrayToBST(self, nums: List[int]) -> Optional[TreeNode]:
        if len(nums) == 1:
            return TreeNode(nums[0])
        if len(nums) > 1:
            if len(nums) % 2 == 1:
                k = int((len(nums)-1)/2)
            else:
                k = int(len(nums)/2)
        
            tree = TreeNode(nums[k])
            tree.left = self.sortedArrayToBST(nums[:k])
            tree.right = self.sortedArrayToBST(nums[(k+1):])
            return tree

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

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

迭代

回忆了一下迭代怎么写右中左，写了一下迭代。
类似之前写遍历的代码，就是在每次append的那个位置，用一个sum来累加，再赋值就可以。

class Solution:
    def convertBST(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
        queue = collections.deque()
        if not root:
            return None
        queue.append(root)
        s = 0
        cur = root
        while queue:
            while cur.right:
                cur = cur.right
                queue.append(cur)
            cur1 = queue.pop()
            s += cur1.val
            cur1.val = s
            if cur1.left:
                cur = cur1.left
                queue.append(cur)
        return root

递归

还是双指针法，是右中左，pre跟着current走，但是这次修改的是pre，因为pre在后面才能累加，这里的顺序记得调节好。
重点：因为这次是跟着pre在累加的，最后一个pre其实没累加到，最后迭代完要记得加上。

class Solution:
    def convertBST(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
        pre = None
        s = 0
        def traverse(root):
            nonlocal pre, s
            if not root:
                return None
            traverse(root.right)
            if pre:
                pre.val = s
            pre = root
            s += root.val
            traverse(root.left)
        
        traverse(root)
        if not root:
            return root
        else:
            pre.val = s
            return root