代码随想录day20

题目一

与上一题类似，注意判断nums数组终止条件用len

lass 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 len(nums) == 0:
            return None

        max_val=max(nums)
        root=TreeNode(max_val)

        max_index=nums.index(max(nums))
        leftpart=nums[:max_index]
        rightpart=nums[max_index+1:]

        root.left=self.constructMaximumBinaryTree(leftpart)
        root.right=self.constructMaximumBinaryTree(rightpart)

        return root

第二题

前序遍历

终止条件：root1为空，返回root2；root2为空，返回root1

在root1树上原地进行操作

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

前序遍历

None现在终止条件前面，避免空指针异常

什么时候需要返回值？只有寻找某一条边（或者一个节点）的时候，递归函数会有bool类型的返回值。返回值是true or false 可以返回，root类型返回可以不用记录，直接return函数值

class Solution(object):
    def searchBST(self, root, val):
        """
        :type root: TreeNode
        :type val: int
        :rtype: TreeNode
        """
        if root is None or root.val==val :
            return root

        if root.val>val:
            return self.searchBST(root.left, val)

        if root.val<val:
            return self.searchBST(root.right, val)
        
        return root

第四题

方法一：

中序遍历，得到单调数组，进行判断

class Solution(object):
    def __init__(self):
        self.vec = []
    def traversal(self, root):
        if root is None:
            return
        self.traversal(root.left)
        self.vec.append(root.val)  # 将二叉搜索树转换为有序数组
        self.traversal(root.right)

    def isValidBST(self, root):
        """
        :type root: TreeNode
        :rtype: bool
        """
        self.vec=[]
        self.traversal(root)
        for i in range(len(self.vec)-1):
            if self.vec[i]>=self.vec[i+1]:
                return False
        return True

方法二，递归

设立初始值float('-inf')

终止条件:遍历到none节点时，其实是一个搜索树，返回true

中序遍历：只判断root.val>maxval即可

函数要返回bool值，用于判断（left&right）

class Solution(object):

    def __init__(self):
        self.maxvalue=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.maxvalue:
            self.maxvalue=root.val
        else:
            return False

        right=self.isValidBST(root.right)

        return left and right