【树-中等】1008. 前序遍历构造二叉搜索树_前序遍历构造二叉搜索树 c-优快云博客

本文链接：https://blog.youkuaiyun.com/kz_java/article/details/119760877

本文介绍了如何根据给定的预序遍历序列创建二叉搜索树，提供了三种实现方法，并解释了如何遵循二叉搜索树的规则确保正确性。通过实例演示了如何应用这些算法解决实际问题。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

【题目】
返回与给定前序遍历 preorder 相匹配的二叉搜索树（binary search tree）的根结点。

(回想一下，二叉搜索树是二叉树的一种，其每个节点都满足以下规则，对于 node.left 的任何后代，值总 < node.val，而 node.right 的任何后代，值总 > node.val。此外，前序遍历首先显示节点 node 的值，然后遍历 node.left，接着遍历 node.right。）

题目保证，对于给定的测试用例，总能找到满足要求的二叉搜索树。

示例：

输入：[8,5,1,7,10,12]
输出：[8,5,10,1,7,null,12]

提示：

1 <= preorder.length <= 100
1 <= preorder[i] <= 10^8
preorder 中的值互不相同

【代码】
在这里插入图片描述

# 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 create(self,nums):
        if not nums:
            return None
        root=TreeNode(nums[0])
        high=len(nums)
        i=0
        flag=False
        for i in range(1,high):
            if nums[0]<nums[i]:
                flag=True
                break
        if flag==False:
            i+=1
        root.left=self.create(nums[1:i])
        root.right=self.create(nums[i:])
        return root

    def bstFromPreorder(self, preorder: List[int]) -> TreeNode:
        if not preorder:
            return None
        return self.create(preorder)

【方法2】
在这里插入图片描述

class Solution:
    def bstFromPreorder(self, preorder: List[int]) -> TreeNode:
        if preorder:
            root = TreeNode(preorder.pop(0))
            l, r = [], []
            for i in preorder:
                if i <= root.val:
                    l += [i]
                else:
                    r += [i]            
            root.left = self.bstFromPreorder(l)
            root.right = self.bstFromPreorder(r)
            return root

【方法3】
在这里插入图片描述

class Solution:
    def bstFromPreorder(self, preorder: List[int]) -> TreeNode:
        def func(q):
            if q:
                p,root=[[],[]],TreeNode(q.pop(0))
                [p[x>root.val].append(x) for x in q]
                root.left=func(p[0])
                root.right=func(p[1])
                return root
        return func(preorder)