代码随想录第二十天：654.最大二叉树、617.合并二叉树、700.二叉搜索树中的搜索、98.验证二叉搜索树

654.最大二叉树  代码随想录

先弄懂了前一天的构造二叉树后自己做出来了

# 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: TreeNode
        """
        if nums == []:
            return None
        root_val = max(nums)
        root = TreeNode(val = root_val)
        separate_idx = nums.index(root_val)
        left_tree = nums[:separate_idx]
        right_tree = nums[separate_idx+1:]
        root.left = self.constructMaximumBinaryTree(left_tree)
        root.right = self.constructMaximumBinaryTree(right_tree)
        return root

617.合并二叉树  代码随想录

这题也做出来了

# 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: TreeNode
        :type root2: TreeNode
        :rtype: 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.二叉搜索树中的搜索  代码随想录

这题还好，也是自己写出来了

# 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: TreeNode
        :type val: int
        :rtype: TreeNode
        """
        if not root:
            return None
        elif root.val > val:
            return self.searchBST(root.left, val)
        elif root.val < val:
            return self.searchBST(root.right, val)
        else:
            return root

98.验证二叉搜索树  代码随想录

这道题有点难度，又不会了，还要复习！

方法一：将二叉树进行一次中序遍历，将结果放入一个数组，然后看看数组是不是递增的就好了

# 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):
        """
        :type root: TreeNode
        :rtype: bool
        """
        nums = self.traversal(root)
        for i in range(1, len(nums)):
            if nums[i] <= nums[i-1]:
                return False
        return True
    
    def traversal(self, root):
        if not root:
            return []
        left = self.traversal(root.left)
        right = self.traversal(root.right)
        return left + [root.val] + 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 __init__(self):
        self.maxVal = float('-inf')

    def isValidBST(self, root):
        """
        :type root: TreeNode
        :rtype: bool
        """
        if root is None:
            return True
        left = self.isValidBST(root.left)
        if root.val <= self.maxVal:
            return False
        else:
            self.maxVal = root.val
        right = self.isValidBST(root.right)
        return left and right

方法三：相当于双指针，设一个pre节点，即找到最左侧的节点，避免了初始化一个最小值

# 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 __init__(self):
        self.pre = None

    def isValidBST(self, root):
        """
        :type root: TreeNode
        :rtype: bool
        """
        if root is None:
            return True
        left = self.isValidBST(root.left)
        if self.pre != None and root.val <= self.pre.val:
            return False
        else:
            self.pre = root
        right = self.isValidBST(root.right)
        return right and left

还要加油，今天比前一天好！