Leetcode 653.两数之和IV Java&Python

给定一个二叉搜索树和一个目标结果，如果 BST 中存在两个元素且它们的和等于给定的目标结果，则返回 true。

案例 1:

输入: 
    5
   / \
  3   6
 / \   \
2   4   7

Target = 9

输出: True

案例 2:

输入: 
    5
   / \
  3   6
 / \   \
2   4   7

Target = 28

输出: False

凡是题目给出的是二叉搜索树而不是二叉树的时候，一定要以二叉搜索树的性质为切入点，这道题目就用到了二叉搜索树中序遍历的结果为有序数组的性质。得到有序数组后，做过167号问题两数之和II的同学会发现题目惊人的一致，采用对撞指针的方式便可高效的得到答案，算法时间复杂度为O(n)。

Java

private List<Integer> list = new ArrayList<>();

    public boolean findTarget(TreeNode root, int k) {
        if (root == null) {
            return false;
        }

        inOrder(root);

        int i = 0;
        int j = list.size() - 1;

        while (i < j) {
            int sum = list.get(i) + list.get(j);
            if (sum == k) {
                return true;
            } else if (sum < k) {
                i++;
            } else {
                j--;
            }
        }
        return false;
    }

    private void inOrder(TreeNode node) {
        if (node == null) {
            return;
        }

        inOrder(node.left);
        list.add(node.val);
        inOrder(node.right);
    }

Python

    list = []

    def findTarget(self, root, k):
        """
        :type root: TreeNode
        :type k: int
        :rtype: bool
        """
        if root is None:
            return False

        self.inOrder(root)

        i = 0
        j = len(self.list) - 1

        while i < j:
            sum = self.list[i] + self.list[j]

            if sum == k:
                return True
            elif sum < k:
                i += 1
            else:
                j -= 1

        return False

    def inOrder(self, node):
        if node is None:
            return

        self.inOrder(node.left)
        self.list.append(node.val)
        self.inOrder(node.right)