leetcode 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.

Example 1:

Input: 
    5
   / \
  3   6
 / \   \
2   4   7

Target = 9

Output: True

Example 2:

Input: 
    5
   / \
  3   6
 / \   \
2   4   7

Target = 28

Output: False

简单题一个。

public boolean findTarget(TreeNode root, int k) {
	HashSet<Integer> hashSet=new HashSet<Integer>();
	return find(root, k, hashSet);
}

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

有大神发现，这是一个BST，就可以用BST的性质来做：

1. 中根遍历 BST，能得到一个从小到大排序的 list
2. 在 排好序的 list 中来解决 Two Sum 问题

public class Solution {
    public boolean findTarget(TreeNode root, int k) {
        if (root == null) return false;
        
        List<Integer> list = new ArrayList<>();
        inOrder(root, list);
        
        int i = 0, j = list.size() - 1;
        while (i < j) {
            int sum = list.get(i) + list.get(j);
            if (sum == k) return true;
            if (sum < k) {
                i++;
            }
            else {
                j--;
            }
        }
        
        return false;
    }
    
    private void inOrder(TreeNode root, List<Integer> list) {
        if (root == null) return;
        
        inOrder(root.left, list);
        list.add(root.val);
        inOrder(root.right, list);
    }
}

这道题有solutions： https://leetcode.com/problems/two-sum-iv-input-is-a-bst/solution/

Solution

---

Approach #1 Using HashSet[Accepted]

Java

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

Complexity Analysis

• Time complexity : $O(n)$. The entire tree is traversed only once in the worst case. Here, $n$ refers to the number of nodes in the given tree.

• Space complexity : $O(n)$. The size of the $set$ can grow upto $n$ in the worst case.

---

Approach #2 Using BFS and HashSet [Accepted]

Java

public class Solution {
    public boolean findTarget(TreeNode root, int k) {
        Set < Integer > set = new HashSet();
        Queue < TreeNode > queue = new LinkedList();
        queue.add(root);
        while (!queue.isEmpty()) {
            if (queue.peek() != null) {
                TreeNode node = queue.remove();
                if (set.contains(k - node.val))
                    return true;
                set.add(node.val);
                queue.add(node.right);
                queue.add(node.left);
            } else
                queue.remove();
        }
        return false;
    }
}

Complexity Analysis

• Time complexity : $O(n)$. We need to traverse over the whole tree once in the worst case. Here, $n$ refers to the number of nodes in the given tree.

• Space complexity : $O(n)$. The size of the $set$ can grow atmost upto $n$.

---

Approach #3 Using BST [Accepted]

Java

public class Solution {
    public boolean findTarget(TreeNode root, int k) {
        List < Integer > list = new ArrayList();
        inorder(root, list);
        int l = 0, r = list.size() - 1;
        while (l < r) {
            int sum = list.get(l) + list.get(r);
            if (sum == k)
                return true;
            if (sum < k)
                l++;
            else
                r--;
        }
        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);
    }
}

Complexity Analysis

• Time complexity : $O(n)$. We need to traverse over the whole tree once to do the inorder traversal. Here, $n$ refers to the number of nodes in the given tree.

• Space complexity : $O(n)$. The sorted $list$ will contain $n$ elements.