代码随想录算法训练营Day 17|Python|654.最大二叉树，617.合并二叉树，700.二叉搜索树中的搜索，98.验证二叉搜索树-CSDN博客

本文链接：https://blog.csdn.net/qq_60959261/article/details/137503902

654.最大二叉树

给定一个不重复的整数数组 nums 。 最大二叉树 可以用下面的算法从 nums 递归地构建:

创建一个根节点，其值为 nums 中的最大值。
递归地在最大值左边的 子数组前缀上 构建左子树。
递归地在最大值右边的 子数组后缀上 构建右子树。

返回 nums 构建的 最大二叉树

解题思路：

递归三步骤

确认递归输入参数：def constructMaximumBinaryTree(self, nums: List[int]) -> Optional[TreeNode]

停止条件：递归过程中不断分割左右区间，当左右区间没有值，为"[]"，不产生TreeNode，返回None

递归逻辑：找出最大值，找到最大index，分左右区间nums，进入递归循环，node.left, node.right赋值

# 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 constructMaximumBinaryTree(self, nums: List[int]) -> Optional[TreeNode]:
        if not nums:
            return None
            # return TreeNode()
        root_value = max(nums)
        root_node = TreeNode(root_value)
        #split the left and right side
        root_index = nums.index(root_value)
        left = nums[:root_index]
        right = nums[root_index+1:]
        root_node.left = self.constructMaximumBinaryTree(left)
        root_node.right = self.constructMaximumBinaryTree(right)
        return root_node

617.合并二叉树

给你两棵二叉树： root1 和 root2 。

想象一下，当你将其中一棵覆盖到另一棵之上时，两棵树上的一些节点将会重叠（而另一些不会）。你需要将这两棵树合并成一棵新二叉树。合并的规则是：如果两个节点重叠，那么将这两个节点的值相加作为合并后节点的新值；否则，不为 null 的节点将直接作为新二叉树的节点。

返回合并后的二叉树。

注意: 合并过程必须从两个树的根节点开始。

解题思路：

确认输入参数：def merge(root1, root2)

停止条件：if not root1: return root2, if not root2； return root1

递归逻辑：在root1上加root2 value，进行递归，返回第一个root1二叉树

# 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 mergeTrees(self, root1: Optional[TreeNode], root2: Optional[TreeNode]) -> Optional[TreeNode]:
        if not root1:
            return root2
        if not root2:
            return root1
        
        #recursive
        root1.val += root2.val
        root1.left = self.mergeTrees(root1.left, root2.left)
        root1.right = self.mergeTrees(root1.right, root2.right)
        return root1

700.二叉搜索树中的搜索

700. 二叉搜索树中的搜索 - 力扣（LeetCode）

给定二叉搜索树（BST）的根节点 root 和一个整数值 val。

你需要在 BST 中找到节点值等于 val 的节点。返回以该节点为根的子树。如果节点不存在，则返回 null 。

解题思路：

递归输入参数：def searchBST(root, val)

停止条件：if root == None or root.val == val: 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 searchBST(self, root: Optional[TreeNode], val: int) -> Optional[TreeNode]:
        if not root or (root.val == val):
            return root#find the value or return None
        if root.val>val:
            #left side
            return self.searchBST(root.left, val)
        elif root.val<val:
            return self.searchBST(root.right, val)

98.验证二叉搜索树

给你一个二叉树的根节点 root ，判断其是否是一个有效的二叉搜索树。

有效二叉搜索树定义如下：

节点的左
子树
只包含小于当前节点的数。
节点的右子树只包含大于当前节点的数。
所有左子树和右子树自身必须也是二叉搜索树。

解题思路：

该题判断二叉搜索树应该找递增顺序，终须递归满足该条件。

输入参数：def isValid(root)

停止条件：if not root: return True

递归逻辑：find max_value=float('-inf'), if max_value < root.val, max_value = root.val, else: return

False

易错步骤：

if root.val > max_value:
    max_value = root.val
    return True  # 这里是错误的，因为还没有检查右子树

正确代码：

# 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 isValidBST(self, root: Optional[TreeNode]) -> bool:
        max_value = float('-inf')
        # a = 1
        def dfs(root):
            nonlocal max_value  # 确保我们可以在嵌套函数中修改外部变量
            if not root:
                return True
            left = dfs(root.left)
            if root.val>max_value:
                max_value = root.val
            else:
                return False
            right = dfs(root.right)
            return left and right
        return dfs(root)