Leetcode| 669. 修剪二叉搜索树、108. 将有序数组转换为二叉搜索树、538. 把二叉搜索树转换为累加树 Day23

669. Trim a Binary Search Tree

递归

# 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:
            return None
        
        # 单层递归逻辑
        if root.val < low:      # 该节点<low，将其右孩子返回给上一层
            return self.trimBST(root.right, low, high)
        if root.val > high:     # 该节点>high，将其左孩子返回给上一层
            return self.trimBST(root.left, low, high)

        root.left = self.trimBST(root.left, low, high)
        root.right = self.trimBST(root.right, low, high)

        return 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:
            return None
        
        # 处理头节点，让其移动到[low, high]的范围
        while root and (root.val < low or root.val > high):
            if root.val < low:
                root = root.right
            if root.val > high:
                root = root.left

        cur = root

        # 处理root的左孩子小于low的情况
        while cur:
            while cur.left and cur.left.val < low:
                cur.left = cur.left.right       # 用应删除节点的右孩子替代
            cur = cur.left

        cur = root

        # 处理root的右孩子大于high的情况
        while cur:
            while cur.right and cur.right.val > high:
                cur.right = cur.right.left
            cur = cur.right

        return root
  

---

108. Convert Sorted Array to Binary Search Tree

找到头节点，再将数组分隔，分别递归

# 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 len(nums) == 0:
            return None
        if len(nums) == 1:
            leafVal = nums[0]
            leaf = TreeNode(leafVal)
            return leaf

        index = len(nums) // 2
        rootVal = nums[index]
        root = TreeNode(rootVal)

        leftNums = nums[:index]
        rightNums = nums[index+1:]

        root.left = self.sortedArrayToBST(leftNums)
        root.right = self.sortedArrayToBST(rightNums)

        return root
        

---

538. Convert BST to Greater Tree

要使[1, 2, 3] -> [6, 5, 3]，需要反向遍历，
所以要对树进行反向中序遍历，用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 __init__(self):
        self.pre = 0

    # 反中序遍历
    def r_inorderTraversal(self, node):
        if node == None:
            return

        self.r_inorderTraversal(node.right)
        node.val += self.pre
        self.pre = node.val                 # 记录前一个节点的数值
        self.r_inorderTraversal(node.left)

    def convertBST(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
        self.r_inorderTraversal(root)
        return 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 __init__(self):
        self.pre = 0

    # 反中序遍历
    def r_inorderTraversal(self, node):
        cur = node
        stack = []
        while stack or cur:
            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: Optional[TreeNode]) -> Optional[TreeNode]:
        self.r_inorderTraversal(root)
        return root