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

最新推荐文章于 2025-12-31 21:25:26 发布

原创最新推荐文章于 2025-12-31 21:25:26 发布 · 297 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#算法

代码随想录算法训练营一刷记录专栏收录该内容

57 篇文章

订阅专栏

本文介绍了如何使用递归和迭代方法修剪二叉搜索树，以及将有序数组转换为二叉搜索树和二叉搜索树转换为累加树的过程。作者通过实例展示了递归和迭代在这些问题中的应用，强调了递归理解的重要性。

669. 修剪二叉搜索树

递归：

总算自己能想明白了！

递归终止：遇到空节点停止。

递归过程：如果一个节点小于low了，说明左子树也都小于low，那就return右子树。反之，大于high说明右子树都大于high，return左子树。如果在范围内，则左边连接递归修剪完的左子树，右边连接递归修剪完的右子树。

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

迭代：

分三步，先修正根节点；再分别修剪左右子树。

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

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

递归：

空数组直接返回None，将数组分成两份，左边一半右边一半，中间取出来的数就是根节点，左边都比他小，右边都比他大，随后递归地连接左子树和右子树。

class Solution:
    def sortedArrayToBST(self, nums: List[int]) -> Optional[TreeNode]:
        if not nums:
            return None
        mid = len(nums) // 2
        root = TreeNode(nums[mid])
        root.left = self.sortedArrayToBST(nums[:mid])
        root.right = self.sortedArrayToBST(nums[mid + 1:])
        return root

迭代：

迭代会复杂一点，使用栈来模拟：

class Solution:
    def sortedArrayToBST(self, nums: List[int]) -> Optional[TreeNode]:
        if not nums:
            return None

        # 中间节点的索引
        mid = len(nums) // 2

        # 创建根节点
        root = TreeNode(nums[mid])

        # 栈用于存储节点和对应的子数组范围
        stack = [(root, 0, mid - 1, mid + 1, len(nums) - 1)]

        while stack:
            node, left_start, left_end, right_start, right_end = stack.pop()

            # 处理左子树
            if left_start <= left_end:
                mid_left = (left_start + left_end) // 2
                node.left = TreeNode(nums[mid_left])
                stack.append((node.left, left_start, mid_left - 1, mid_left + 1, left_end))

            # 处理右子树
            if right_start <= right_end:
                mid_right = (right_start + right_end) // 2
                node.right = TreeNode(nums[mid_right])
                stack.append((node.right, right_start, mid_right - 1, mid_right + 1, right_end))

        return root

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

递归：

双指针，右中左遍历。

class Solution:
    def __init__(self, prev = None):
        self.prev = prev
    def convertBST(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
        if not root:
            return root
        self.convertBST(root.right)
        if self.prev:
            root.val += self.prev.val
        self.prev = root
        self.convertBST(root.left)
        return root

迭代：

class Solution:
    def convertBST(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
        if not root:
            return root
        
        stack = []
        cur = root
        prev = None
        while stack or cur:
            while cur:
                stack.append(cur)
                cur = cur.right
            cur = stack.pop()
            if prev:
                cur.val += prev.val
            prev = cur
            cur = cur.left
        return root

今日总结：

太感动了，自己能写这些递归了！！

感觉刷完整个二叉树章节，对递归、递归回溯有了比较深刻的理解。