代码随想录算法训练营Day18 | Leetcode 669修剪二叉搜索树、108将有序数组转换为二叉搜索树、538把二叉搜索树转换为累加树

原创已于 2025-04-03 23:27:04 修改 · 998 阅读

21 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

于 2025-04-02 16:03:32 首次发布

代码随想录算法训练营Day18 | Leetcode 669修剪二叉搜索树、108将有序数组转换为二叉搜索树、538把二叉搜索树转换为累加树

一、修剪二叉搜索树

相关题目：Leetcode669
文档讲解：Leetcode669
视频讲解：Leetcode669

1. Leetcode669.修剪二叉搜索树

给你二叉搜索树的根节点 root ，同时给定最小边界low 和最大边界 high。通过修剪二叉搜索树，使得所有节点的值在[low, high]中。修剪树 不应该 改变保留在树中的元素的相对结构 (即，如果没有被移除，原有的父代子代关系都应当保留)。可以证明，存在 唯一的答案 。
所以结果应当返回修剪好的二叉搜索树的新的根节点。注意，根节点可能会根据给定的边界发生改变。

思路：
- 递归法：
  - 确定递归函数的参数以及返回值：因为是要遍历整棵树并做修改，有返回值更方便，可以通过递归函数的返回值来移除节点。其实不需要返回值也可以完成修剪（其实就是从二叉树中移除节点）的操作。
  - 确定终止条件：修剪的操作并不是在终止条件上进行的，所以遇到空节点返回就可以了。
  - 确定单层递归的逻辑：
    - 如果 root（当前节点）的元素小于 low 的数值，那么应该递归右子树，并返回右子树符合条件的头结点。
    - 如果 root （当前节点）的元素大于 high 的数值，那么应该递归左子树，并返回左子树符合条件的头结点。
- 迭代法：因为二叉搜索树的有序性，不需要使用栈模拟递归的过程。在剪枝的时候，可以分为三步：
  - 将 root 移动到 [L, R] 范围内，注意是左闭右闭区间。
  - 剪枝左子树。
  - 剪枝右子树。
递归法

class Solution:
    def trimBST(self, root: TreeNode, low: int, high: int) -> TreeNode:
        if root is None:
            return None
        if root.val < low:
            # 寻找符合区间 [low, high] 的节点
            return self.trimBST(root.right, low, high)
        if root.val > high:
            # 寻找符合区间 [low, high] 的节点
            return self.trimBST(root.left, low, high)
        root.left = self.trimBST(root.left, low, high)  # root.left 接入符合条件的左孩子
        root.right = self.trimBST(root.right, low, high)  # root.right 接入符合条件的右孩子
        return root

迭代法

class Solution:
    def trimBST(self, root: TreeNode, L: int, R: int) -> TreeNode:
        if not root:
            return None
        
        # 处理头结点，让root移动到[L, R] 范围内，注意是左闭右闭
        while root and (root.val < L or root.val > R):
            if root.val < L:
                root = root.right  # 小于L往右走
            else:
                root = root.left  # 大于R往左走
        
        cur = root
        
        # 此时root已经在[L, R] 范围内，处理左孩子元素小于L的情况
        while cur:
            while cur.left and cur.left.val < L:
                cur.left = cur.left.right
            cur = cur.left
        
        cur = root
        
        # 此时root已经在[L, R] 范围内，处理右孩子大于R的情况
        while cur:
            while cur.right and cur.right.val > R:
                cur.right = cur.right.left
            cur = cur.right
        
        return root

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

相关题目：Leetcode108
文档讲解：Leetcode108
视频讲解：Leetcode108

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

给你一个整数数组 nums ，其中元素已经按升序排列，请你将其转换为一棵平衡二叉搜索树。

思路：
- 一个高度平衡二叉树是指一个二叉树每个节点的左右两个子树的高度差的绝对值不超过 1。
- 递归法：
  - 确定递归函数返回值及其参数：删除二叉树节点，增加二叉树节点，用递归函数的返回值来完成比较方便。参数依次是数组，左下标 left 和右下标 right ，此处定义采用左闭右闭区间。
  - 确定递归终止条件：这里定义的是左闭右闭的区间，所以当区间 left > right 的时候，就是空节点了。
  - 确定单层递归的逻辑：取中间位置，以中间位置的元素构造节点，接着划分区间，root 的左孩子接住下一层左区间构造的节点，右孩子接住下一层右区间构造的节点。
- 迭代法：可以通过三个队列来模拟，一个队列放遍历的节点，一个队列放左区间下标，一个队列放右区间下标，模拟取中间元素，然后不断分割去构造二叉树的过程。
递归法

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

##递归 精简(自身调用)
class Solution:
    def sortedArrayToBST(self, nums: List[int]) -> Optional[TreeNode]:
        if not nums:
            return
        mid = len(nums) // 2
        root = TreeNode(nums[mid])
        root.left = self.sortedArrayToBST(nums[:mid])
        root.right = self.sortedArrayToBST(nums[mid + 1 :])
        return root

迭代法

from collections import deque

class Solution:
    def sortedArrayToBST(self, nums: List[int]) -> TreeNode:
        if len(nums) == 0:
            return None
        
        root = TreeNode(0)  # 初始根节点
        nodeQue = deque()   # 放遍历的节点
        leftQue = deque()   # 保存左区间下标
        rightQue = deque()  # 保存右区间下标
        
        nodeQue.append(root)               # 根节点入队列
        leftQue.append(0)                  # 0为左区间下标初始位置
        rightQue.append(len(nums) - 1)     # len(nums) - 1为右区间下标初始位置

        while nodeQue:
            curNode = nodeQue.popleft()
            left = leftQue.popleft()
            right = rightQue.popleft()
            mid = left + (right - left) // 2

            curNode.val = nums[mid]  # 将mid对应的元素给中间节点

            if left <= mid - 1:  # 处理左区间
                curNode.left = TreeNode(0)
                nodeQue.append(curNode.left)
                leftQue.append(left)
                rightQue.append(mid - 1)

            if right >= mid + 1:  # 处理右区间
                curNode.right = TreeNode(0)
                nodeQue.append(curNode.right)
                leftQue.append(mid + 1)
                rightQue.append(right)

        return root

三、把二叉搜索树转换为累加树

相关题目：Leetcode538
文档讲解：Leetcode538
视频讲解：Leetcode538

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

给出二叉搜索树的根节点，该树的节点值各不相同，请你将其转换为累加树（Greater Sum Tree），使每个节点 node 的新值等于原树中 大于或等于 node.val 的值之和。
提醒一下，二叉搜索树满足下列约束条件：

节点的左子树仅包含键小于节点键的节点。
节点的右子树仅包含键大于节点键的节点。
左右子树也必须是二叉搜索树。

思路：
- 如果是一个升序数组，则可以采用倒序相加实现累加；而二叉搜索树的中序遍历便可得到升序数组，故可以看出累加的顺序是右中左，所以我们需要反中序遍历这个二叉树，然后顺序累加就可以了。
- 递归法：
  - 递归函数参数以及返回值：不需要递归函数的返回值，要遍历整棵树。同时需要定义一个全局变量 pre，用来保存 cur 节点的前一个节点的数值，定义为 int 型即可。
  - 确定终止条件：遇空就终止。
  - 确定单层递归的逻辑：注意要右中左来遍历二叉树，中节点的处理逻辑就是让 cur 的数值加上前一个节点的数值。
- 迭代法：采用中序遍历（右中左），利用 pre 指针进行累加即可。
递归法

##递归法(版本一)
# 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: TreeNode) -> TreeNode:
        self.pre = 0  # 记录前一个节点的数值
        self.traversal(root)
        return root
    def traversal(self, cur):
        if cur is None:
            return        
        self.traversal(cur.right)
        cur.val += self.pre
        self.pre = cur.val
        self.traversal(cur.left)

##递归法（版本二）
class Solution:
    def __init__(self):
        self.count = 0

    def convertBST(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
        if root == None:
            return 
        '''
        倒序累加替换：  
        '''
        # 右
        self.convertBST(root.right)

        # 中
        # 中节点：用当前root的值加上pre的值
        self.count += root.val

        root.val = self.count 

        # 左
        self.convertBST(root.left)

        return root

迭代法

##迭代法（版本一）
class Solution:
    def __init__(self):
        self.pre = 0  # 记录前一个节点的数值
    
    def traversal(self, root):
        stack = []
        cur = root
        while cur or stack:
            if cur:
                stack.append(cur)
                cur = cur.right  # 右
            else:
                cur = stack.pop()  # 中
                cur.val += self.pre
                self.pre = cur.val
                cur = cur.left  # 左
    
    def convertBST(self, root):
        self.pre = 0
        self.traversal(root)
        return root

##迭代法（版本二）
class Solution:
    def convertBST(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
        if not root: return root
        stack = []
        result = []
        cur = root
        pre = 0
        while cur or stack:
            if cur:
                stack.append(cur)
                cur = cur.right
            else: 
                cur = stack.pop()
                cur.val+= pre
                pre = cur.val
                cur =cur.left
        return root