【代码随想录】【二叉树】补day20：最大二叉树，二叉搜索树等

最大二叉树

从数组中选取最大的节点作为根节点，该数左侧的全部作为左子树的部分，右侧的全部作为右子树 依此类推。

思路：构造二叉树都要前序遍历 先构造根节点，再遍历构造左右子树

class solution:
    def contrut(self,nums:List[int]):
        # 定义终止条件，如果需要处理的数组为空，那就返回，停止递归

        if not nums:
            return

        # 中
        max_i=max(nums)
        index=nums.index(max_i)
        root=TreeNode(max_i)

        # 左
        left=nums[0:index]
        root.left=self.contrut(left)
        # 右
        right=nums[index+1:]
        root.right=self.contrut(right)

        return root

合并二叉树

思路：两个二叉树同时遍历，步骤相同，方向相同，可以直接在某一棵树上直接修改添加，如果当前节点为空，则直接取另一棵树对应的节点；如果节点不为空，则相加

 def CombineBinaryTree(self,node1:TreeNode,node2:TreeNode):
        # 递归函数的终止条件，即什么时刻不继续向下递归而是返回
        # 由于两个二叉树是同时遍历，那么当
        #如果当前节点为空，则直接取另一棵树对应的节
        if node1 is None:
            return node2

        if node2 is None:
            return node1

        # 如果节点不为空，则相加
        node1.val+=node2.val
        
        #递归左右

        node1.left=self.CombineBinaryTree(node1.left,node2.left)
        node1.right=self.CombineBinaryTree(node1.right,node2.right)

        return node

二叉搜索树中的搜索

给定二叉搜索树（BST）的根节点和一个值。 你需要在BST中找到节点值等于给定值的节点。 返回以该节点为根的子树。 如果节点不存在，则返回 NULL。

感觉还挺简单的

  def SearchBSTTree(self,node:TreeNode,target:int):
        if node is None:
            return

        if node.val==target:
            return node
        elif node.val >target:
            self.SearchBSTTree(node.left,target)
        elif node.val <target:
            self.SearchBSTTree(node.right,target)

验证二叉搜索树【一个根节点比左子树所有节点都大，比右子树所有节点都小】

1.定义一个数组，中序遍历存入，然后判断数组是不是单调递增

# 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 __init__(self):
        self.vec = []

    def traversal(self, root):
        if root is None:
            return
        self.traversal(root.left)
        self.vec.append(root.val)  # 将二叉搜索树转换为有序数组
        self.traversal(root.right)

    def isValidBST(self, root):
        self.vec = []  # 清空数组
        self.traversal(root)
        for i in range(1, len(self.vec)):
            # 注意要小于等于，搜索树里不能有相同元素
            if self.vec[i] <= self.vec[i - 1]:
                return False
        return True

2.不额外申请空间，直接中序遍历比较

class Solution:
    def __init__(self):
        self.maxVal = float('-inf')  # 因为后台测试数据中有int最小值

    def isValidBST(self, root):
        if root is None:
            return True

        left = self.isValidBST(root.left)
        # 中序遍历，验证遍历的元素是不是从小到大
        if self.maxVal < root.val:
            self.maxVal = root.val
        else:
            return False
        right = self.isValidBST(root.right)

        return left and right