代码随想录day20|654. 最大二叉树617. 合并二叉树700. 二叉搜索树中的搜索98. 验证二叉搜索树

654. 最大二叉树

# 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 nums == []:
            return 
        max_index= nums.index(max(nums))
        root = TreeNode(nums[max_index])
        if len(nums[:max_index]) ==1:
            root.left = TreeNode(nums[:max_index])
        if len(nums[max_index+1:]) ==1:
            root.right = TreeNode(nums[max_index+1:])
        root.left = self.constructMaximumBinaryTree(nums[:max_index])
        root.right = self.constructMaximumBinaryTree(nums[max_index+1:])
        return root

617. 合并二叉树

# 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: TreeNode, root2: TreeNode) -> TreeNode:
        #没明白两件事第一个是返回root是头节点还是尾节点，是头节点，每一层都要有新的root，最后一层是尾节点
        #会通过递归回传，最终得到的是头节点，所以定义新节点要在函数里面，如果另写一个函数，改变self.root，这样得到的是尾节点root
        # 递归终止条件: 
        #  但凡有一个节点为空, 就立刻返回另外一个. 如果另外一个也为None就直接返回None. 
        if not root1: 
            return root2
        if not root2: 
            return root1
        # 上面的递归终止条件保证了代码执行到这里root1, root2都非空. 
        root = TreeNode() # 创建新节点
        root.val += root1.val + root2.val# 中
        root.left = self.mergeTrees(root1.left, root2.left) #左
        root.right = self.mergeTrees(root1.right, root2.right) # 右
        
        return root # ⚠️ 注意: 本题我们创建了新节点. 

700. 二叉搜索树中的搜索

# 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 root == None or root.val == val:
            return root
        if root.val>val:
            result=self.searchBST(root.left,val)
            return result
        else:
            result=self.searchBST(root.right,val)
            return result

98. 验证二叉搜索树

# 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:
#         if root==None:
#             return True
#         if root.left and root.val <= root.left.val:
#             return False
#         if root.right and root.val >=root.right.val:
#             return False
#         left_bool = self.isValidBST(root.left)
#         right_bool = self.isValidBST(root.right)
#         index_r,index_l = root,root
#         if root.right:
#             index_r = root.right
#             while index_r.left:
#                 index_r=index_r.left
#         if root.left:
#             index_l = root.left
#             while index_l.right:
#                 index_l=index_l.right
#         print(root.val,index_r.val,index_l.val)
#         flag = True
#         flag = (root.val < index_r.val or root== index_r )and (root.val >index_l.val or root== index_l)
#         return left_bool and right_bool and flag
class Solution:
    def __init__(self):
        self.pre = None  # 用来记录前一个节点

    def isValidBST(self, root):
        if root is None:
            return True

        left = self.isValidBST(root.left)

        if self.pre is not None and self.pre.val >= root.val:
            return False
        self.pre = root  # 记录前一个节点

        right = self.isValidBST(root.right)
        return left and right