代码随想录算法训练营day20 | 654.最大二叉树 | 617.合并二叉树 | 700.二叉搜索树中的搜索 | 98.验证二叉搜索树

654.最大二叉树

凡是构造二叉树类的题目都用前序遍历

主要确定结束递归的条件：子树长度为1时就停

class Solution:
    """最大二叉树 递归法"""

    def constructMaximumBinaryTree(self, nums: List[int]) -> TreeNode:
        return self.traversal(nums, 0, len(nums))
    
    def traversal(self, nums: List[int], begin: int, end: int) -> TreeNode:
        # 列表长度为0时返回空节点
        if begin == end:
            return None
        
        # 找到最大的值和其对应的下标
        max_index = begin
        for i in range(begin, end):
            if nums[i] > nums[max_index]:
                max_index = i
        
        # 构建当前节点
        root = TreeNode(nums[max_index])
        
        # 递归构建左右子树
        root.left = self.traversal(nums, begin, max_index)
        root.right = self.traversal(nums, max_index + 1, end)
        
        return root

 617.合并二叉树

在原节点上做修改，不创建新节点 

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def mergeTrees(self, root1: TreeNode, root2: TreeNode) -> TreeNode:
        # 递归终止条件: 
        #  但凡有一个节点为空, 就立刻返回另外一个. 如果另外一个也为None就直接返回None. 
        if not root1: 
            return root2
        if not root2: 
            return root1
        # 上面的递归终止条件保证了代码执行到这里root1, root2都非空. 
        root1.val += root2.val # 中
        root1.left = self.mergeTrees(root1.left, root2.left) #左
        root1.right = self.mergeTrees(root1.right, root2.right) # 右
        
        return root1 # ⚠️ 注意: 本题我们重复使用了题目给出的节点而不是创建新节点. 节省时间, 空间. 

700.二叉搜索树中的搜索

二叉搜索树本身自带顺序，所以递归和遍历都很简单

递归法

class Solution:
    def searchBST(self, root: TreeNode, val: int) -> TreeNode:
        # 为什么要有返回值: 
        #   因为搜索到目标节点就要立即return，
        #   这样才是找到节点就返回（搜索某一条边），如果不加return，就是遍历整棵树了。

        if not root 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)

迭代法

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

98.验证二叉搜索树 

 中序搜索二叉搜索树的时候，取出来的值是依次增大的。

这个题稍微有一点点复杂

class Solution:
    def isValidBST(self, root: TreeNode) -> bool:
        # method 2
        que, pre = [], None
        while root or que:
            while root:
                que.append(root)
                root = root.left
            root = que.pop()
            # 对第一个节点只做记录，对后面的节点进行比较
            if pre is None:
                pre = root.val
            else:
                if pre >= root.val: return False
                pre = root.val
            root = root.right
        return True