LeetCode-Python-270. 最接近的二叉搜索树值

原创已于 2024-09-11 01:40:00 修改 · 1.6k 阅读

3 ·

CC 4.0 BY-SA版权

文章标签：

#BST #数组

于 2019-05-21 17:11:27 首次发布

Leetcode 同时被 2 个专栏收录

821 篇文章

订阅专栏

Python

664 篇文章

订阅专栏

博客围绕在非空二叉搜索树中找最接近目标值 target 的数值展开。目标值为浮点数，且树中仅存在一个最接近的数。给出两种思路，一是中序遍历后在数组里找，时间和空间复杂度均为 O（N）；二是利用二分思想，最坏时间和空间复杂度为 O（N），平均为 O（logN）。

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

给定一个不为空的二叉搜索树和一个目标值 target，请在该二叉搜索树中找到最接近目标值 target 的数值。

注意：

给定的目标值 target 是一个浮点数
题目保证在该二叉搜索树中只会存在一个最接近目标值的数

示例：

输入: root = [4,2,5,1,3]，目标值 target = 3.714286

    4
   / \
  2   5
 / \
1   3

输出: 4

第一种思路：

中序遍历然后在得到的数组里找最接近的数。

时间复杂度：O（N）

空间复杂度：O（N）

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def closestValue(self, root, target):
        """
        :type root: TreeNode
        :type target: float
        :rtype: int
        """
        def inorder(node):
            if not node:
                return []
            return inorder(node.left) + [node.val] + inorder(node.right)
        nums = inorder(root)
        res = root.val
        minum = 2 ** 32
        # print nums
        for i, x in enumerate(nums):
            distance = abs(target - x)
            print distance, minum, res
            if distance < minum:
                res = x
                minum = distance
        return res

第二种思路：

利用二分的思想，每一次我们可以在知道 target 在树的左边还是右边。

时间复杂度：最坏 O（N)，平均O（logN）

空间复杂度：最坏 O（N），平均O（logN）

# 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 closestValue(self, root: Optional[TreeNode], target: float) -> int:
        if not root:
            return -1
        
        if not root.left and not root.right:
            return root.val
        
        if root.val > target:
            # target should be the left subtree + root
            left = self.closestValue(root.left, target)
            # compare left and root
            return self.getClosestValue(root.val, left, target)
        else:
            right = self.closestValue(root.right, target)
            return self.getClosestValue(root.val, right, target)
    
    def getClosestValue(self, val1, val2, target):
        if abs(val1 - target) < abs(val2 - target):
            return val1
        elif abs(val1 - target) > abs(val2 - target):
            return val2
        return min(val1, val2)