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

一、LeetCode669. 修剪二叉搜索树

        1：题目描述（669. 修剪二叉搜索树）

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

        所以结果应当返回修剪好的二叉搜索树的新的根节点。注意，根节点可能会根据给定的边界发生改变。

        2：解题思路

        自己最开始的写法：

# 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]:
        def deleteNode(cur):
            if cur == None:
                # 当前节点为空，直接返回None
                return None
            while cur.val < low or cur.val > high:
                if cur.val < low:
                    # 当前节点的值，比给的最小值要小，就需要把当前节点删除，并且比当前节点小的都要删除。
                    # 有以下四种情况
                    # 1:当前节点的左右子节点均为空，则直接删除节点，向上返回None
                    if cur.left == None and cur.right == None:
                        print("left==None and right==None")
                        return None
                    # 2：当前节点的左节点为空，右节点不为空,需要继续判断右节点的值是否在范围外
                    elif cur.left == None and cur.right != None:
                        cur = cur.right
                        print(cur)
                    # 3:当前节点的左节点不为空，右节点为空，因为是二叉搜索树，所以当前节点比左子树中的所有值都要大，则需要把当前节点和左子树的所有节点都删除
                    elif cur.left != None and cur.right == None:
                        return None
                    # 4:当前节点的左右节点均不为空，左子树需要删除，右子树的值需要继续判断是否在范围外
                    else:
                        cur = cur.right
                        print("you",cur)
                if cur.val > high:
                    if cur.left == None and cur.right == None:
                        return None
                    elif cur.left == None and cur.right != None:
                        return None
                    elif cur.left != None and cur.right == None:
                        cur = cur.left
                    else:
                        cur = cur.left
                        print("zuo",cur)
            cur.left = deleteNode(cur.left)
            cur.right = deleteNode(cur.right)
            return cur
        return deleteNode(root)

        看了代码随想录的是视频后：

# 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 root == None:
            # 当前节点等于None，则向上返回None
            return None
        if root.val < low:
            # 当当前节点值小于范围的最小值时，当前节点的左子树的值就都小于最小值了
            # 当前节点的右子树中，可能有节点的值在范围内，可能有节点的值不在范围内
            # 因此继续向右进行遍历
            right = self.trimBST(root.right, low, high)
            return right
        if root.val > high:
            # 当当前节点值大于范围的最大值时，当前节点的右子树的值就都大于最大值了
            # 当前节点的左子树中，可能有节点的值在范围内，可能有节点的值不在范围内
            # 因此继续向左进行遍历
            left = self.trimBST(root.left, low, high)
            return left
        # 当节点的值在范围内，则继续向左右进行遍历
        root.left = self.trimBST(root.left, low, high)
        root.right = self.trimBST(root.right, low, high)
        return root

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

        1：题目描述（108. 将有序数组转换为二叉搜索树）

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

        高度平衡 二叉树是一棵满足「每个节点的左右两个子树的高度差的绝对值不超过 1 」的二叉树。

        2：解题思路

# 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]:
        if not nums:
            return None
        # 将数组中间的值作为根节点
        node_index = len(nums)//2
        # 定义节点
        node = TreeNode(nums[node_index])
        # 分割数组，左边为左子树的节点
        node_left = nums[:node_index]
        # 右边为右子树的节点
        node_right = nums[node_index+1:]
        # 获取节点的左右子树
        node.left = self.sortedArrayToBST(node_left)
        node.right = self.sortedArrayToBST(node_right)
        return node

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

        1：题目描述（538. 把二叉搜索树转换为累加树）

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

        提醒一下，二叉搜索树满足下列约束条件：

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

        2：解题思路

# 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 __init__(self):
        self.pre = 0
    def convertBST(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
        # 本题使用的遍历顺序是：右中左
        if root == None:
            # 当节点为None，则返回None
            return None
        # 向右遍历
        self.convertBST(root.right)
        # 将pre的值与当前节点的值相加，作为当前节点的值
        root.val = root.val + self.pre
        # 再将当前节点的值，赋值给pre
        self.pre = root.val
        # 向左遍历
        self.convertBST(root.left)
        return root