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

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

  • 669. 修剪二叉搜索树
  • 108. 将有序数组转换为二叉搜索树
  • 538. 把二叉搜索树转换为累加树
    • 迭代
    • 递归

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

你可能感兴趣的:(刷题日常,算法,leetcode,数据结构,python)