653. Two Sum IV - Input is a BST

题目描述：

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));
    }
}