【代码随想录算法训练营】第20天 | 第六章 二叉树（六）

主要内容

• 655.最大二叉树
• 617.合并二叉树
• 700.二叉搜索树中的搜索
• 98.验证二叉搜索树

题目

655.最大二叉树

题目描述

添加链接描述

思路分析

在用数组构造二叉树时，每次分隔尽量不要新建数组，而是通过下标索引在原数组上操作，节省时间空间。

代码

# 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 constructMaximumBinaryTree(self, nums: List[int]) -> Optional[TreeNode]:
        if len(nums) == 0:
            return None
        rootval = max(nums)
        root = TreeNode(rootval)
        rootid = nums.index(rootval)
        leftnums = nums[:rootid]
        rightnums = nums[rootid+1:]
        root.left = self.constructMaximumBinaryTree(leftnums)
        root.right = self.constructMaximumBinaryTree(rightnums)
        return root

class Solution:
    def constructMaximumBinaryTree(self, nums: List[int]) -> Optional[TreeNode]:
        return self.traversal(nums, 0, len(nums))

    # 不新建数组，用索引操作，节省空间
    def traversal(self, nums, left, right):
        if left >= right:
            return None
        maxid = left
        for i in range(left,right):
            if nums[i] > nums[maxid]:
                maxid = i
        root = TreeNode(nums[maxid])
        root.left = self.traversal(nums, left, maxid)
        root.right = self.traversal(nums, maxid+1, right)
        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: Optional[TreeNode], root2: Optional[TreeNode]) -> Optional[TreeNode]:
        if not root1 and not root2:
            return None
        elif not root1 and root2:
            rootval = root2.val
        elif root1 and not root2:
            rootval = root1.val
        elif root1 and root2:
            rootval = root1.val + root2.val
        root = TreeNode(rootval)
        
        root1left = root1.left if root1 else None
        root1right = root1.right if root1 else None
        root2left = root2.left if root2 else None
        root2right = root2.right if root2 else None
        
        root.left = self.mergeTrees(root1left, root2left)
        root.right = self.mergeTrees(root1right, root2right)
        
        return root

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.二叉搜索树中的搜索

题目描述

添加链接描述

思路分析

递归要有return self.searchBST(root.left, val) 和 return self.searchBST(root.right, val)
== 否则的话 ==
加return 因为要把找到的节点递归的传回去
不加的话，只在找到后传给了上一层,上一层的结果却没法返回给最外层

代码

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

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
        return None

98.验证二叉搜索树

题目描述

添加链接描述

思路分析

中序遍历，是否递增

代码

class Solution:
    def isValidBST(self, root: Optional[TreeNode]) -> bool:
        nodes = []
        def traversal(root):
            nonlocal nodes
            if not root:
                return
            traversal(root.left)
            nodes.append(root.val)
            traversal(root.right)

        traversal(root)
        for i in range(1, len(nodes)):
            if nodes[i] <= nodes[i-1]:
                return False
        return True

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

        def __isValidBST(root):
            nonlocal curmax
            if not root:
                return True
            left_is = __isValidBST(root.left)
            if curmax < root.val:
                curmax = root.val
            else:
                return False
            right_is = __isValidBST(root.right)
            return left_is and right_is
        return __isValidBST(root)