Day 20 代码随想录

---

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_index=nums.index(root_val)
        root=TreeNode(root_val)
        #拆分
        left_root=nums[:root_index]
        right_root=nums[root_index+1:]

        root.left=self.constructMaximumBinaryTree(left_root)
        root.right=self.constructMaximumBinaryTree(right_root)
        return root

root.left 和 root.right直接再次递归就可以。

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 root1==None:
            return root2
        if root2==None:
            return root1
        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, val: int) :
        # 为什么要有返回值: 
        #   因为搜索到目标节点就要立即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)
        

要注意root就是一个根节点带两个子节点

迭代法

class Solution:
    def searchBST(self, root, val: int) :
        while not root:
            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: Optional[TreeNode]) -> bool:
        res=[]
        def traveral(root):
            # nonlocal res
            if not root:
                return 
            
            traveral(root.left)
            res.append(root.val)
            traveral(root.right)
        
        def Issorted(nums):
            for i in range(1,len(nums)):
                if nums[i]<=nums[i-1]:
                    return False
                
            return True
        traveral(root)
        result=Issorted(res)
        return result

判断是否是单调函数

一般单调

class Solution:
    def isMonotonic(self, A):
        """
        :type A: List[int]
        :rtype: bool
        """
        return A == sorted(A) or A == sorted(A)[::-1]#递增或者递减

严格单调

def Issoerde(nums):
	# 双指针
    left=0
    right=1
    while right<len(nums):
        if nums[left]<nums[right]:
            left+=1
            right+=1
        else:
            return False
    return True


def Issorted(nums):# 遍历
    for i in range(1, len(nums)):
        print(i)
        if nums[i] <= nums[i - 1]:
            return False
    return True