653. Two Sum IV - Input is a BST

最新推荐文章于 2024-06-02 16:09:57 发布

when_bounce

最新推荐文章于 2024-06-02 16:09:57 发布

阅读量184

点赞数

分类专栏： LeetCode

本文链接：https://blog.csdn.net/DirBee/article/details/79042664

版权

LeetCode 专栏收录该内容

48 篇文章

订阅专栏

本文介绍三种方法来解决二叉搜索树中是否存在两个元素之和等于给定目标值的问题。方法包括使用哈希表、将BST转换为排序数组后双指针查找以及直接在BST中递归搜索配对元素。

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

题目描述：

Given a Binary Search Tree and a target number, return true if there exist two elements in the BST such that their sum is equal to the given target.

class TreeNode {
      int val;
      TreeNode left;
      TreeNode right;
      TreeNode(int x) { val = x; }
  }

思路一：

用一个哈希表保存下BST中结点的值，每次新插入一个结点的值的时候，都判断哈希表中是否已经包含了k-node.val。

时间复杂度为O(n)，空间复杂度为O(n)。

class Solution {
    public boolean findTarget(TreeNode root, int k) {
        HashSet<Integer> set = new HashSet<>();
        return dfs(root, set, k);
    }

    public boolean dfs(TreeNode root, HashSet<Integer> set, int k)
    {
        if (root == null)
            return false;
        if (set.contains(k - root.val))
            return true;
        set.add(root.val);
        return dfs(root.left, set, k) || dfs(root.right, set, k);
    }
}

思路二：

对BST做前序遍历，得到一个排序后的数组，使用两个下标，一个从头开始，一个从尾开始，找是否存在和k。

时间复杂度O(n)，空间复杂度O(n)。

class Solution {
    public boolean findTarget(TreeNode root, int k) {
        List<Integer> list = new ArrayList<>();
        inorder(root, list);
        for (int i = 0, j = list.size() - 1; i < j;)
        {
            if (list.get(i) + list.get(j) == k) return true;
            else if (list.get(i) + list.get(j) < k) i++;
            else j--;
        }
        return false;
    }

    public void inorder(TreeNode root, List<Integer> list)
    {
        if (root == null)
            return;
        inorder(root.left, list);
        list.add(root.val);
        inorder(root.right, list);
    }
}

思路三：

使用二叉查找的方法，对每一个结点，检查BST中是否存在k-node.val。

h是树的高度，最好情况下为logn，最差情况下为n。

时间复杂度为O(nlogn)，空间复杂度为O(h)。

class Solution {
    public boolean findTarget(TreeNode root, int k) {
        return dfs(root, root, k);
    }

    public boolean dfs(TreeNode root, TreeNode curr, int k)
    {
        if (curr == null)
            return false;
        return search(root, curr, k - curr.val) || dfs(root, curr.left, k) || dfs(root, curr.right, k);
    }
    public boolean search(TreeNode root, TreeNode curr, int value)
    {
        if (root == null)
            return false;
        return (root.val == value && root != curr) || (root.val < value && search(root.right, curr, value)) || (root.val > value && search(root.left, curr, value));
    }
}