day15-数据结构力扣

看不懂所有，感觉到二叉树这边难度就明显上升，特别是构建二叉树这一块

654.最大二叉树

题目链接654. 最大二叉树 - 力扣（LeetCode）

思路

比如321605

先找最大的6作为根节点，6的左边321作为左子树节点，6的右边05作为右子树节点

选321里面最大的数3作为左子树里面的根节点，21作为3的右节点，选2，选1

选05里面最大的数5作为右子树里面的根节点，0在5左边，所以是5的左子树

构造顺序，中左右，先确定根节点，所以用前序遍历

递归法：

1.确定函数的参数和返回值：参数传入的是存放元素的数组，返回该数组构造的二叉树的头结点

2.确定终止条件：题目中说了输入的数组大小一定是大于等于1的，所以我们不用考虑小于1的情况，那么当递归遍历的时候，如果传入的数组大小为1，说明遍历到了叶子节点了。

3.确定单层的递归逻辑

先要找到数组中最大的值和对应的下标，最大的值构造根节点，下标用来下一步分割数组。

最大值的左区间构建左子树

最大值的右区间构建右子树

提交

python 复制代码

# 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
        max_val=max(nums)
        max_index=nums.index(max_val)
        node=TreeNode(max_val)
        node.left=self.constructMaximumBinaryTree(nums[:max_index])
        node.right=self.constructMaximumBinaryTree(nums[max_index+1:])
        return node

617.合并二叉树

题目链接617. 合并二叉树 - 力扣（LeetCode）

思路

就是递归的方法，但是我还不是很会写递归

但是我发现，就是如果你要处理一个节点，他的逻辑跟之前写的几乎一样，你就可以看看，能不能省略，然后直接写递归解决

其实我最开始写是把这几排写出来了

python 复制代码

        if not root1:
            return root2
        if not root2:
            return root1
        root=TreeNode(root1.val+root2.val)

然后我想处理root.left，要判断1的是不是空，2的是不是空，然后再把他们加起来。写到这里顿住了，我说这和前面好像差不多。然后看了一下题解，是在这里写递归处理。

提交

python 复制代码

# 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:
            return root2
        if not root2:
            return root1
        root=TreeNode(root1.val+root2.val)
        root.left=self.mergeTrees(root1.left,root2.left)
        root.right=self.mergeTrees(root1.right,root2.right)
        return root

700.二叉搜索树中的搜索

题目链接 700. 二叉搜索树中的搜索 - 力扣（LeetCode）

思路

需要了解一下二叉搜索树

二叉搜索树的定义

二叉搜索树（Binary Search Tree, BST）是一种特殊的二叉树，满足以下性质：

对于任意节点，其左子树中所有节点的值均小于该节点的值。
对于任意节点，其右子树中所有节点的值均大于该节点的值。
左右子树也必须是二叉搜索树。

二叉搜索树的操作

插入节点

从根节点开始，比较待插入值与当前节点值：

若小于当前节点值，进入左子树递归插入。
若大于当前节点值，进入右子树递归插入。
若等于当前节点值，通常根据需求处理（如忽略或更新）。

python 复制代码

class TreeNode:
    def __init__(self, val):
        self.val = val
        self.left = None
        self.right = None

def insert(root, val):
    if not root:
        return TreeNode(val)
    if val < root.val:
        root.left = insert(root.left, val)
    else:
        root.right = insert(root.right, val)
    return root

查找节点

从根节点开始，比较目标值与当前节点值：

若等于当前节点值，返回该节点。
若小于当前节点值，进入左子树递归查找。
若大于当前节点值，进入右子树递归查找。

python 复制代码

def search(root, val):
    if not root or root.val == val:
        return root
    if val < root.val:
        return search(root.left, val)
    return search(root.right, val)

提交

python 复制代码

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

我之前写错了一个地方，就是，我刚开始判断val不在root里，然后直接返回[]空列表

1.if val not in list(root)（判断val在不在root里）这里就错在root不能强制转换为列表

2.返回空列表,也不对，返回类型没有看清楚。

最后改成一个很普通的代码

if not root:

return None

我在想如果要找的值不在root里面呢，返回值也是正确吗

不在树里时，返回 None 就是题目要求的正确结果。

找到了 → 返回对应子树节点
没找到 → 走到 root == None，返回 None

98.验证二叉搜索树

题目链接 98. 验证二叉搜索树 - 力扣（LeetCode）

思路

写的时候感觉有点不对劲，运行一下，过了！难道我是天才

提交

就过了运行的那两个，2/86

因为我这里加入了root的左右节点的值判断，但是前面只判断了root是否为空，所以这里应该是空节点的一个报错。

但是不知道怎么改，而且感觉其他地方写的也有错，四面漏风

换一个思路，我直接中序遍历得到结果，去重，然后判断结果是否从小到大排列，对比数组结果是否相等。

提交

python 复制代码

# 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:
        if not root:
            return True
        res=self.traversal(root)
        res1=list(set(res))
        res1.sort()
        return res==res1

        
    def traversal(self,root:Optional[TreeNode])->List:
        if not root:
            return []
        return self.traversal(root.left)+[root.val]+self.traversal(root.right)