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

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

今日总结：

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

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