[LeetCode] 1214. Two Sum BSTs

Given the roots of two binary search trees, root1 and root2, return true if and only if there is a node in the first tree and a node in the second tree whose values sum up to a given integer target.

Example 1:

Input: root1 = [2,1,4], root2 = [1,0,3], target = 5
Output: true
Explanation: 2 and 3 sum up to 5.

Example 2:

Input: root1 = [0,-10,10], root2 = [5,1,7,0,2], target = 18
Output: false

Constraints:

• The number of nodes in each tree is in the range [1, 5000].
• -109 <= Node.val, target <= 109

查找两棵二叉搜索树之和。

给出两棵二叉搜索树，请你从两棵树中各找出一个节点，使得这两个节点的值之和等于目标值 Target。如果可以找到返回 True，否则返回 False。

提示：

每棵树上最多有 5000 个节点。
-10^9 <= target, node.val <= 10^9

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/two-sum-bsts
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

这道题我给出两种思路。一是利用hashset，二是利用BST的中序遍历。

hashset 的做法是，我们为这两棵树各自创建一个 hashset 来记录这两棵树里面的节点值。记录好以后，我们遍历其中一个 hashset 的值 val，并在另一个 hashset 里找是否存在 target - val，如果存在则 return true。

时间O(n)

空间O(n)

Java实现

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public boolean twoSumBSTs(TreeNode root1, TreeNode root2, int target) {
        HashSet<Integer> set1 = new HashSet<>();
        HashSet<Integer> set2 = new HashSet<>();
        helper(root1, set1);
        helper(root2, set2);
        for (int num : set1) {
            if (set2.contains(target - num)) {
                return true;
            }
        }
        return false;
    }

    private void helper(TreeNode root, HashSet<Integer> set) {
        if (root == null) {
            return;
        }
        set.add(root.val);
        helper(root.left, set);
        helper(root.right, set);
    }
}

 

BST 的中序遍历的做法是，我们为这两棵树各自创建一个 stack，我们暂且记为 stack1 和 stack2。对于 root1，我们做中序遍历，一开始不停地把左子树加入 stack1；对于 root2，我们做逆向的中序遍历，一开始不停地把右子树加入 stack2。因为 BST 在做中序遍历的时候结果是有序的，所以 root1 的遍历结果是递增的，root2 的遍历结果是递减的。如果 root1.val + root2.val < target 则需要再找 root1 中序遍历的下一个节点，因为他会使得 root1.val + root2.val 更大；反之则需要再找 root2 逆向中序遍历的下一个节点，因为他会使得 root1.val + root2.val 更小。

时间O(n)

空间O(n)

Java实现

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public boolean twoSumBSTs(TreeNode root1, TreeNode root2, int target) {
        // corner case
        if (root1 == null || root2 == null) {
            return false;
        }

        // normal case
        Deque<TreeNode> stack1 = new ArrayDeque<>();
        Deque<TreeNode> stack2 = new ArrayDeque<>();
        TreeNode t1;
        TreeNode t2;
        while (true) {
            while (root1 != null) {
                stack1.push(root1);
                root1 = root1.left;
            }
            while (root2 != null) {
                stack2.push(root2);
                root2 = root2.right;
            }
            if (stack1.isEmpty() || stack2.isEmpty()) {
                break;
            }

            t1 = stack1.peek();
            t2 = stack2.peek();
            if (t1.val + t2.val == target) {
                return true;
            }
            // inorder traversal for root1
            else if (t1.val + t2.val < target) {
                stack1.pop();
                root1 = t1.right;
            }
            // inorder traversal for root2
            else {
                stack2.pop();
                root2 = t2.left;
            }
        }
        return false;
    }
}

 

LeetCode 题目总结