代码随想录刷题day20| 654.最大二叉树 & 617.合并二叉树 & 700.二叉搜索树中的搜索 & 98.验证二叉搜索树

 654.最大二叉树

递归：

class Solution(object):
    def constructMaximumBinaryTree(self, nums):
        if not nums:   # 允许空节点进入递归
            return None
        num_max = max(nums)
        node = TreeNode(num_max)   
        node_index = nums.index(num_max)
        node.left = self.constructMaximumBinaryTree(nums[0 : node_index])
        node.right = self.constructMaximumBinaryTree(nums[node_index + 1 : len(nums)])
        return node

【思考】 #这一版的终止条件不要用

        if len(nums) == 1:
            return TreeNode(nums[0])

这是不允许空节点入递归，后面要加判断，否则像nums = [3,2,1,6,0,5]，当递归到nums[0:3]的时候，是空的，所以num_max = max(nums)会报错。如果要用这样的终止条件，可以这样写：

class Solution:
    def constructMaximumBinaryTree(self, nums: List[int]) -> TreeNode:
        if len(nums) == 1:
            return TreeNode(nums[0])
        node = TreeNode(0)
        # 找到数组中最大的值和对应的下标
        maxValue = 0
        maxValueIndex = 0
        for i in range(len(nums)):
            if nums[i] > maxValue:
                maxValue = nums[i]
                maxValueIndex = i
        node.val = maxValue
        # 最大值所在的下标左区间 构造左子树
        if maxValueIndex > 0:
            new_list = nums[:maxValueIndex]
            node.left = self.constructMaximumBinaryTree(new_list)
        # 最大值所在的下标右区间 构造右子树
        if maxValueIndex < len(nums) - 1:
            new_list = nums[maxValueIndex+1:]
            node.right = self.constructMaximumBinaryTree(new_list)
        return node

617.合并二叉树

递归：

class Solution(object):
    def mergeTrees(self, root1, root2):
        if not root1:          
            return root2
        if not root2:
            return root1
        root = TreeNode()   # 创造一个新节点，别忘了先转化成节点形式
        root.val = root1.val + root2.val   #中
        root.left = self.mergeTrees(root1.left, root2.left)   #左
        root.right = self.mergeTrees(root1.right, root2.right)  #右
        return root

 【思考】采用的是前序递归顺序

700.二叉搜索树中的搜索 

递归：

class Solution(object):
    def searchBST(self, root, val):
        if not root:
            return None
        if root.val == val:
            return root

        if root.val > val:
            return self.searchBST(root.left, val)   # 要加return！
        if root.val < val:
            return self.searchBST(root.right, val)

        # 为什么要有返回值: 
        #   因为搜索到目标节点就要立即return，
        #   这样才是找到节点就返回（搜索某一条边），如果不加return，就是遍历整棵树了

迭代：

class Solution(object):
    def searchBST(self, root, val):
        while root:
            if val < root.val:
                root = root.left
            elif val > root.val:
                root = root.right
            else:
                return root
        return None

【思考】充分利用了搜索二叉树的定义：

二叉搜索树是一个有序树：

• 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值；
• 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；
• 它的左、右子树也分别为二叉搜索树

这就决定了，二叉搜索树，递归遍历和迭代遍历和普通二叉树都不一样。

这道题迭代非常好做。

98.验证二叉搜索树

这道题迭代能理解，但中序迭代顺序感觉很复杂，不好写，有时间再试试递归。