day20|二叉树6-最大二叉树、合并二叉树、二叉搜索树

654.最大二叉树

利用前序遍历的方式，构造二叉树。
复习二叉树的构建步骤：

1. 找到父节点的值
2. 分割列表，生成父节点对应的左右子树
3. 针对左右子树进行递归
4. 返回递归的结果，为当前结点的根节点。
5. 在返回根节点的同时，需要创建相对应的叶子结点对象。

class Solution:
    def constructMaximumBinaryTree(self, nums: List[int]) -> Optional[TreeNode]:
        if not nums:
            return 
        # 找到结点的划分
        n = len(nums)
        maxValue = max(nums)
        index = nums.index(maxValue)
        # 针对当前结点创建树结点
        root = TreeNode(maxValue)
        leftTree = nums[0:index]
        rightTree = nums[index+1:n]
        # 分别生成当前结点的左子树和右子树
        root.left = self.constructMaximumBinaryTree(leftTree)
        root.right = self.constructMaximumBinaryTree(rightTree)
        return root

617.合并二叉树

在递归算法的实现中，需要确定递归方式最终返回的值是何值，本题所返回的值是递归方式的到的根节点的值。

class Solution:
    def mergeTrees(self, root1: Optional[TreeNode], root2: Optional[TreeNode]) -> Optional[TreeNode]:
        # 递归的方式关键在于找到一个递归的函数体
        def dfs(root1,root2):
            # 遍历两棵树，通过设置判断条件确定两棵树的连接情况
            if not root1 or not root2:
                return root1 if root1 else root2
            root = TreeNode()
            root.val = root1.val + root2.val
            root.left = dfs(root1.left,root2.left)
            root.right = dfs(root1.right,root2.right)
            return root
        return dfs(root1,root2)

700.二叉搜索树中的搜索

二叉搜索树： 左子树均小于根结点的数值，右子树均大于根节点的数值。
如果使用递归法：不需要强调前序和后序，二叉树自带顺序。

总结递归算法的求解步骤：

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

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

98.验证二叉搜索树

中序遍历： 中序遍历（左中右）的顺序是不是单调递增的，如果在中序的情况下是单调递增的话，就说明此时的树是一个二叉搜索树。

常见错误：×
如果使用如下的方法只判断了当前结点的左孩子和右孩子，并没有比较左子树和右子树的所有值，因而如果使用此种方式的话，会产生错误。
所以应该记录的是左子树的最大结点和右子树的最小节点

class Solution:
    def isValidBST(self, root: Optional[TreeNode]) -> bool:
        # 确定递归函数的返回值，利用前序的方式进行求解。
        def dfs(root):
            if not root.left and root.right:
                return True if root.val < root.right.val else False
            if root.left and not root.right:
                return True if root.val > root.left.val else False
            if root.left and root.right:
                return True if root.val > root.left.val and root.val < root.right.val else False
            if not root.left and not root.right:
                return True
            left = dfs(root.left)
            right = dfs(root.right)
            return  left and right  
        return dfs(root)

class Solution:
    def isValidBST(self, root: Optional[TreeNode]) -> bool:
        # 需要设置一个全局变量，分析全局变量与当前结点之间的关系
        cur_max = -float('inf')
        def isValidBST(root):
            nonlocal cur_max
            if not root:
                return True
            # 利用左中右的顺序
            isLeftValid = isValidBST(root.left)
            if cur_max < root.val:
                cur_max = root.val
            else: 
                return False
            isRightValid = isValidBST(root.right)
            return isLeftValid and isRightValid
        return isValidBST(root)