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

654.最大二叉树 

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

跟 二叉树：构造二叉树登场！思路一样

# 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 not nums:
            return None 
        
        #根节点 
        root_val = max(nums)
        root = TreeNode(root_val)

        #分割值
        sep_id = nums.index(root_val)

        #左右子树
        left = nums[:sep_id]
        right = nums[sep_id+1:]

        #递归
        root.left = self.constructMaximumBinaryTree(left)
        root.right = self.constructMaximumBinaryTree(right)

        return root

617.合并二叉树 

题目链接/文章讲解：代码随想录

视频讲解：一起操作两个二叉树？有点懵！| LeetCode：617.合并二叉树_哔哩哔哩_bilibili

        if not root1 and not root2:
            return None
        
       

 最开始终止条件写成了这个是错的，一定要想好终止条件怎么写

正确代码如下：

# 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]:
    #终止条件
    #但凡有一个节点为空, 就立刻返回另外一个. 如果另外一个也为None就直接返回None.     
        if not root1:
            return root2
        if not root2:
            return root1
    
    #上面的递归终止条件保证了代码执行到这里root1, root2都非空.     
    
    #中
        root_val = root1.val + root2.val 
        root = TreeNode(root_val)
    #左
        root.left = self.mergeTrees(root1.left,root2.left)
    #右
        root.right = self.mergeTrees(root1.right,root2.right)

        return root

 700.二叉搜索树中的搜索 

题目链接/文章讲解: 代码随想录

视频讲解：不愧是搜索树，这次搜索有方向了！| LeetCode：700.二叉搜索树中的搜索_哔哩哔哩_bilibili

 

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

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

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

(终止条件还是会写错)

# 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 searchBST(self, root: Optional[TreeNode], val: int) -> Optional[TreeNode]:
        if  not root or val == root.val:
            return root 

        result = None
        if val<root.val:
             result = self.searchBST(root.left,val)
             return result
        if val>root.val:
            result = self.searchBST(root.right,val)
            return result 
        return result

递归函数还有返回值，所以用一个变量将其接住，所以要 result = searchBST(root.left, val)

迭代法：

因为二叉搜索树的特殊性，也就是节点的有序性，可以不使用辅助栈或者队列就可以写出迭代法。

对于一般二叉树，递归过程中还有回溯的过程，例如走一个左方向的分支走到头了，那么要调头，在走右分支。

而对于二叉搜索树，不需要回溯的过程，因为节点的有序性就帮我们确定了搜索的方向。

# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def searchBST(self, root: Optional[TreeNode], val: int) -> Optional[TreeNode]:
        while root != None:
            if val<root.val:
                root = root.left 
            elif val>root.val:
                root = root.right 
            else:
                return root 
        return None

 98.验证二叉搜索树

题目链接/文章讲解：代码随想录

视频讲解：你对二叉搜索树了解的还不够！ | LeetCode：98.验证二叉搜索树_哔哩哔哩_bilibili

要知道中序遍历下，输出的二叉搜索树节点的数值是有序序列。

有了这个特性，验证二叉搜索树，就相当于变成了判断一个序列是不是递增的了。

递归法（版本一）利用中序递增性质，转换成数组:

# 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 not root:
            return 
        self.traversal(root.left)
        self.vec.append(root.val)
        self.traversal(root.right)

    def isValidBST(self, root: Optional[TreeNode]) -> bool:
        self.traversal(root)
        for i in range(1,len(self.vec)):
            if self.vec[i-1]>=self.vec[i]:
                return False
        return True
        

 递归法（版本二）设定极小值，进行比较

# 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.maxval = float('-inf')

    def isValidBST(self, root: Optional[TreeNode]) -> bool:
        if not root: 
            return True

        left = self.isValidBST(root.left)

        if root.val>self.maxval:
            self.maxval = root.val
        else:
             return False 
        
        right = self.isValidBST(root.right)

        return left and right

递归法（版本三）直接取该树的最小值 

# 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.pre = None

    def isValidBST(self, root: Optional[TreeNode]) -> bool:
        if not root: 
            return True

        left = self.isValidBST(root.left)

        if self.pre != None and self.pre>=root.val:
             return False 
        self.pre = root.val # 记录前一个节点
        
        right = self.isValidBST(root.right)

        return left and right