【代码随想录训练营】【Day 26】【二叉树-9】| Leetcode 669, 108, 583

最新推荐文章于 2024-07-09 23:43:07 发布

花花啊啦啦啦

最新推荐文章于 2024-07-09 23:43:07 发布

阅读量315

点赞数 9

文章标签： leetcode 算法职场和发展

本文链接：https://blog.csdn.net/qq_44574200/article/details/139201887

版权

【代码随想录训练营】【Day 26】【二叉树-9】| Leetcode 669, 108, 583

需强化知识点

滑动窗口，固定结束位置版本
螺旋数组，建模为编程问题

题目

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 not root:
            return None
        
        if root.val < low:
            left = self.trimBST(root.right, low, high)
            return left
        if root.val > high:
            right = self.trimBST(root.left, low, high)
            return right
        
        root.left = self.trimBST(root.left, low, high)
        root.right = self.trimBST(root.right, low, high)

        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 traverse(nums, left, right):
            if left > right or left < 0 or right >= len(nums):
                return None
            mid = (left + right) // 2
            node = TreeNode(val = nums[mid])
            node.left = traverse(nums, left, mid-1)
            node.right = traverse(nums, mid+1, right)
            return node
        
        root = traverse(nums, 0, len(nums)-1)
        return root

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

右中左进行遍历，记录prev的值，依次遍历

# 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.prev = 0
        # def traverse(node):
        #     if not node:
        #         return 
        #     traverse(node.right)
        #     node.val += self.prev
        #     self.prev = node.val
        #     traverse(node.left)
        
        # traverse(root)
        # return root

        if not root:
            return
        stack = []
        prev = 0
        cur = root

        while cur or stack:
            if cur:
                stack.append(cur)
                cur = cur.right
            else:
                cur = stack.pop()
                cur.val += prev
                prev = cur.val
                cur = cur.left
        return root