代码随想录算法训练营第十七天| 654.最大二叉树、617.合并二叉树、700.二叉搜索树中的搜索、98.验证二叉搜索树

今日题目

654.最大二叉树

题目链接：654. 最大二叉树 - 力扣（LeetCode）

思考：本题方法类似106. 从中序与后序遍历序列构造二叉树 - 力扣（LeetCode），都是通过寻找最大值作为根节点，最大值左右两侧元素用于构建该根节点的左右子树，采用递归思想。

代码：

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def constructMaximumBinaryTree(self, nums):
        """
        :type nums: List[int]
        :rtype: Optional[TreeNode]
        """
        if not nums:
            return None
        # 找到最大值及其下标
        root_val = max(nums)
        root_index = nums.index(root_val)
        # 依据最大值构建根节点
        root = TreeNode(root_val)
        # 划分左子树和右子树
        root_left = nums[:root_index]
        root_right = nums[root_index+1:]
        # 构建左右子树
        root.left = self.constructMaximumBinaryTree(root_left)
        root.right = self.constructMaximumBinaryTree(root_right)

        return root

617.合并二叉树

题目链接：617. 合并二叉树 - 力扣（LeetCode）

思考：本题可以理解为将一个二叉树叠加到另一个二叉树上，如果对应位置节点重叠，则两棵树的对应节点值相加，如果对应位置一棵树有节点另一个无节点，则该位置直接采用有节点的树的节点，同样采用递归思想构建左右子树。

代码：

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def mergeTrees(self, root1, root2):
        """
        :type root1: Optional[TreeNode]
        :type root2: Optional[TreeNode]
        :rtype: Optional[TreeNode]
        """
        if not root1:
            return root2
        if not root2:
            return root1

        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）

思考：二叉搜索树的规律是，对于所有的节点，其左节点数值小于根节点，右节点数值大于根节点，因此二叉搜索树是有序的。

需要判断的只有三种情况，即根节点为空或根节点的数值等于目标值、大于目标值和小于目标值。

第一种情况直接返回根节点，第二种情况需要递归到左子树，第三种情况需要递归到右子树。

代码：

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def searchBST(self, root, val):
        """
        :type root: Optional[TreeNode]
        :type val: int
        :rtype: Optional[TreeNode]
        """
        if not root or root.val == val:
            return root
        if root.val > val:
            cur = root.left
            result = self.searchBST(cur, val)
        if root.val < val:
            cur = root.right
            result = self.searchBST(cur, val)
        return result

98.验证二叉搜索树

题目链接：98. 验证二叉搜索树 - 力扣（LeetCode）

思考：二叉搜索树的规律是，对于所有的节点，其左节点数值小于根节点，右节点数值大于根节点。

判断一棵树是否是二叉搜索树，即需要对每一个节点，判断其与左右子节点的大小关系是否满足left<x<right。

本题还是采用递归思想，需要注意的是在递归左右子树时，左子树的数值右边界是根节点值，右子树的左边界值是根节点值。

代码：

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def isValidBST(self, root, left=-2**32, right=2**32):
        """
        :type root: Optional[TreeNode]
        :rtype: bool
        """
        if root is None:
            return True
        x = root.val
        return left<x<right and self.isValidBST(root.left, left, x) and self.isValidBST(root.right, x, right)