leetcode算法训练十七天| 654.最大二叉树， 617.合并二叉树 ，700.二叉搜索树中的搜索， 98.验证二叉搜索树

 617.合并二叉树 

学习视频：又是构造二叉树，又有很多坑！| LeetCode：654.最大二叉树_哔哩哔哩_bilibili

学习文档：代码随想录 (programmercarl.com)

学习时间：10：00-10：21（最早学习的一集）

记录时间：10：22-10：47

状态：已听懂|可单独复写代码|暂时不复习

1. 看到问题后的初始想法与看完随想录后的心得 

        本题与昨天的根据中序遍历与后序遍历生成二叉树的题目类似，都需要我们去把当前数组分为左右子树的数组。方法还是递归，具体思路如下：

1. 递归的输入与输出：递归的输入为当前需要划分树的数组，输出为当前划分树的根节点。
2. 递归的终止条件：当剩下数组长度为1时，直接把剩下的值变为叶子节点并返回。
3. 递归的单层逻辑：因为这是构造二叉树，所以我们必须按前序遍历的顺序来构造。首先找出数组的最大值作为根节点，接下来划分左右子树的数组并判断其长度是否大于0，如果大于0就将当前根节点的左右孩子分配给他们（涉及递归）

具体代码如下：

# 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 len(nums) == 1:
            leaf = TreeNode(val=nums[0])
            return leaf
        
        maxval = 0
        index = 0
        for i in range(len(nums)):
            if nums[i] > maxval:
                maxval = nums[i]
                index = i

        root = TreeNode(val=nums[index])
        
        if index > 0:
            left_list = nums[0:index]
            root.left = self.constructMaximumBinaryTree(left_list)

        if index < len(nums)-1:
            right_list = nums[index+1:len(nums)]
            root.right = self.constructMaximumBinaryTree(right_list)

        return root

 617.合并二叉树 

学习视频：一起操作两个二叉树？有点懵！| LeetCode：617.合并二叉树_哔哩哔哩_bilibili

学习文档：代码随想录 (programmercarl.com)

记录时间：20:12-20:25

状态：已听懂|可单独复写代码|暂时不复习

1. 看到问题后的初始想法与看完随想录后的心得 

        这题依旧是一道递归的题目，我就在这里简单的写一下思路，难度可能是操作两个二叉树。

1. 递归的输入和输出：递归的输入为第一棵树的根节点与第二棵树的根节点。输出为二叉树结合后的根节点。
2. 递归的终止条件：当第一棵树的根节点为空时，直接输出第二棵树对应的节点，同理，当第二棵树的根节点为空时，直接输出第一棵树对应都节点。
3. 递归的单层逻辑：首先把对应的左右节点的数值加起来，然后对该节点的左右节点再次进行递归（求左右子树的二叉树合并），最后输出当前节点。

# 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 root1 is None:
            return root2
        if root2 is None:
            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.二叉搜索树中的搜索

学习视频：一起操作两个二叉树？有点懵！| LeetCode：617.合并二叉树_哔哩哔哩_bilibili

学习文档：代码随想录 (programmercarl.com)

学习时间：20:25-20:35

记录时间：20:35-

状态：已听懂|可单独复写代码|暂时不复习

1. 看到问题后的初始想法与看完随想录后的心得 

        这是一道非常简单的题目，有多简单呢，我这个代码萌新都可以一次写出来递归方法（迭代稍微想了下也觉得蛮简单的，但是时间问题就写递归了。

1. 递归的输入和输出：递归的输入为下一个搜索节点，输出为None或者是匹配好的根节点。
2. 递归的终止条件：递归的终止条件为当前查找的节点为空，则返回None，或者当前返回的节点的值等于搜索值，则返回匹配好的节点。
3. 递归的单层逻辑：当目标数值大于根节点，则遍历右子树寻找，反之则遍历左子树寻找。

代码如下：

# 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 root1 is None:
            return root2
        if root2 is None:
            return root1
        root1.val += root2.val
        root1.left = self.mergeTrees(root1.left, root2.left)
        root1.right = self.mergeTrees(root1.right, root2.right)
        return root1

 98.验证二叉搜索树

学习视频：你对二叉搜索树了解的还不够！ | LeetCode：98.验证二叉搜索树_哔哩哔哩_bilibili

学习文档：代码随想录 (programmercarl.com)

学习时间：21:00-21:42

记录时间：21:42-21：48

状态：已听懂|可单独复写代码|暂时不复习

1. 看到问题后的初始想法与看完随想录后的心得

        因为时间原因直接看视频了解了思路，下面我将从递归的角度来说一下这道题。

1. 递归的输入与输出：递归的输出是要验证二项搜索树子树的根节点，输出为bool值True或False。
2. 递归的终止条件：有两个终止条件，一个是当前节点为空，返回True。第二个是当前节点的数值小于前一个节点的数值（我们此时采用的是中序遍历，因此遍历出来应该是从小到大按顺序排的，同时这个条件需要放到遍历左子树的递归的后面），返回False
3. 递归的单层遍历：类似于中序遍历，先递归遍历左子树，再检查中间节点与前一个节点的数值大小，再遍历右子树。

# 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
        """

        global pre
        pre = None
        def isValid(root):
            if root is None:
                return True
            global pre
            
            valid_left = isValid(root.left)
            if pre is not None and root.val <= pre:
                return False
            pre = root.val
            valid_right = isValid(root.right)
            return valid_left and valid_right        
        result = isValid(root)
        return result