算法记录 | Day20 二叉树

654.最大二叉树

思路：

构造树一般采用的是前序遍历，因为先构造中间节点，然后递归构造左子树和右子树。

1.找到nums中 最大值及其索引，创建根节点

2.分割数组

3.递归左右子树

class Solution:
    def constructMaximumBinaryTree(self, nums: List[int]) -> Optional[TreeNode]:
        if not nums:
            return None

        root_val = max(nums)
        root_idx = nums.index(root_val)
        root = TreeNode(root_val)

        nums_left = nums[:root_idx]
        nums_right = nums[root_idx+1:]

        root.left = self.constructMaximumBinaryTree(nums_left)
        root.right = self.constructMaximumBinaryTree(nums_right)

        return root

617.合并二叉树

递归

思路：

1.确定递归参数和返回值：输入root1，root2，返回新的root

2.终止条件：t1为空，return t2，t2为空，return t1

3.单层逻辑：利用t1更新，合并t1根节点，更新t1左子树，t1右子树

class Solution:
    def mergeTrees(self, root1: Optional[TreeNode], root2: Optional[TreeNode]) -> Optional[TreeNode]:
        if not root1:
            return root2
        if not root2:
            return root1
        root1.val += root2.val
        root1.left = self.mergeTrees(root1.left, root2.left)
        root1.right = self.mergeTrees(root1.right, root2.right)
        return root1

迭代

class Solution:
    def mergeTrees(self, root1: Optional[TreeNode], root2: Optional[TreeNode]) -> Optional[TreeNode]:
        if not root1:
            return root2
        if not root2:
            return root1

        que = []
        que.append(root1)
        que.append(root2)
        while que:
            node1 = que.pop(0)
            node2 = que.pop(0)
            node1.val += node2.val
            if node1.left and node2.left:
                que.append(node1.left)
                que.append(node2.left)
            if node1.right and node2.right:
                que.append(node1.right)
                que.append(node2.right)

            if not node1.left and node2.left:
                node1.left = node2.left

            if not node1.right and node2.right:
                node1.right = node2.right
        return root1

700.二叉搜索树中的搜索

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

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

递归

思路：

1.确定递归参数和返回：输入root，返回为val的节点

2.终止条件：root为空 or root.val ==val, return root

3.单层逻辑：根据BTS性质，判断root.val大小，搜索root左右 子树

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)
        if 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:
                return self.searchBST(root.left, val)
            elif root.val < val:
                return self.searchBST(root.right, val)
            else:
                return root

98.验证二叉搜索树

二叉搜索树中序遍历，有序数组

递归

1. 以前序遍历为例，递归函数为：preorderTraversal(root, minv, maxv)
2. 前序遍历时，先判断根节点的值是否在minv、maxv之间。
   1. 如果不在则直接返回 False。
   2. 如果在区间内，则继续递归检测左右子树是否满足，都满足才是一棵二叉搜索树。
3. 当递归遍历左子树的时候，要将上界 maxv 改为左子树的根节点值，因为左子树上所有节点的值均小于根节点的值。
4. 当递归遍历右子树的时候，要将下界 min_v 改为右子树的根节点值，因为右子树上所有节点的值均大于根节点。

# 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 isValidBST(self, root: Optional[TreeNode]) -> bool:
        def preorderTraversal(root, minv, maxv):
            if not root:
                return True
            if root.val >=maxv or root.val <= minv:
                return False    
            return preorderTraversal(root.left,minv,root.val) and preorderTraversal(root.right,root.val,maxv)
        return  preorderTraversal(root, float('-inf'),float('inf'))