最大二叉树+合并二叉树 +二叉搜索树中的搜索+验证二叉搜索树（day20）

LC654. 最大二叉树

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

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

返回 nums 构建的 最大二叉树 。

这里有一个python的函数小技巧，求nums中最大值下标的方法，先求maval，然后i = nums.index(maxval)。

class Solution:

    def constructMaximumBinaryTree(self, nums: List[int]) -> Optional[TreeNode]:
        if not nums: return None
        maxval = max(nums)
        i = nums.index(maxval)
        node = TreeNode(maxval)
        left = nums[0:i]
        right = nums[i+1:]
        node.left = self.constructMaximumBinaryTree(left)
        node.right = self.constructMaximumBinaryTree(right)
        return node

LC617. 合并二叉树

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

思路：（1）先序遍历。（2）因为要进行结点之间链接的操作，所以要有返回值，返回结点。（3）其中，画一下图就可以看出来，如果一棵树为空，直接返回另一棵树即可。（4）直接在root1上处理，可以节约空间。

class Solution:
    def mergeTrees(self, root1: Optional[TreeNode], root2: Optional[TreeNode]) -> Optional[TreeNode]:

        if not root1 and not root2: return root1
        if not root1 and root2:
            return root2
        if root1 and not root2:
            return root1
        if root1 and root2:
            root1.val = root1.val + root2.val
            root1.left = self.mergeTrees(root1.left, root2.left)
            root1.right = self.mergeTrees(root1.right, root2.right)
        return root1

也可以使用队列模拟的层序遍历。同时将两个树的根结点加入队列。进行如下迭代：当队列不为空，同时弹出两个结点n1、n2，并将两棵树的值相加赋给n1，如果两个结点的左孩子不为空，左孩子同时入队；右孩子不为空，则右孩子同时入队；n1的左（右）孩子空，n2不为空，则将n2的左（右）孩子赋给n1即可。最后返回根节点。代码就不写了。

LC700. 二叉搜索树中的搜索

给定二叉搜索树（BST）的根节点 root 和一个整数值 val。你需要在 BST 中找到节点值等于val 的节点。 返回以该节点为根的子树。 如果节点不存在，则返回 null 。

根据二叉搜索树的性质，我们只需要在val小（大）于节点的时候去左（右）子树上去搜索，直到空结点或查找到为止。

class Solution:
    def searchBST(self, root: Optional[TreeNode], val: int) -> Optional[TreeNode]:

            if not root or val == root.val:
                return root
            elif val < root.val:
                return self.searchBST(root.left, val)
            else:
                return self.searchBST(root.right, val)

迭代法也比较简单，根据二叉搜索树性质，都不需要用栈了。

class Solution:
    def searchBST(self, root: Optional[TreeNode], val: int) -> Optional[TreeNode]:
            p = root
            while p:
                if p.val == val:
                    return p
                elif val < p.val:
                    p = p.left
                else:
                    p = p.right
            return p

LC98. 验证二叉搜索树

给你一个二叉树的根节点 root ，判断其是否是一个有效的二叉搜索树(这里二叉搜索树不可以是等于)。

思路1: 递归法的中序遍历，可以对中序遍历后的序列进行判断它是否有序。也可以直接通过比较maxval判断。这里熟悉一下外部的maxval，在函数里面调用时时self.maxval即可。

class Solution:
    maxval = float('-inf')
    def isValidBST(self, root: Optional[TreeNode]) -> bool:

        if not root: return True
        if not self.isValidBST(root.left): return False
        if root.val <= self.maxval:
            return False
        else:
            self.maxval = root.val
        if not self.isValidBST(root.right): return False
        return True

思路2：迭代法中序遍历还没掌握，有时间再补上。