js java 给定一个目标值，在一棵树中找是否有两个节点的值之和等于目标值

在leetCode看到一题目

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

于是用js造一棵树，然后尝试实现

/**
         * [tree 树]
         * val 节点值
         * leftTree 左树(null代表没有左树)
         * rightTree 右树(null代表没有右树)
         */
        var myTree = {
            val: 5,
            leftTree:{
                val: 3,
                leftTree:{
                    val: 2,
                    leftTree: null,
                    rightTree: null
                },
                rightTree: {
                    val: 4,
                    leftTree: null,
                    rightTree: null
                }
            },
            rightTree:{
                val: 6,
                leftTree: null,
                rightTree: {
                    val: 7,
                    leftTree: null,
                    rightTree: null
                },
            }
        }

        //主方法
        function findTarget(tree, k) {
            //用于存储遍历过的节点的值
            var set = [];
            //查找
            return find(tree, k, set);
        }

        //查找方法
        function find(tree, k, set){
            //如果节点为空直接返回false,不需要考虑根节点为空的情况，因为不可能
            if(null == tree){
                return false;
            }

            //看集合中是否包含 目标数(k)-节点值(root.val)
            if(set.indexOf(k-tree.val) > -1){
                return true;
            }

            //将当前节点值存进集合
            set.push(tree.val);

            //对本树的左右节点进行判断，递归
            return find(tree.leftTree, k, set) || find(tree.rightTree, k, set);
        }

        //testing
        console.log(findTarget(myTree, 14));

java版的

 /**
  * Definition for a binary tree node.
  * public class TreeNode {
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
  *     TreeNode(int x) { val = x; }
  * }
  */
 class Solution {
     //主方法
     public boolean findTarget(TreeNode root, int k) {
         //用于存储遍历过的节点的值
         HashSet<Integer> set = new HashSet<Integer>();
         //查找
         return find(root, k, set);
     }

     //查找方法
     public boolean find(TreeNode root, int k, HashSet<Integer> set){
         //如果节点为空直接返回false,不需要考虑根节点为空的情况，因为不可能
         if(null == root){
             return false;
         }

         //看集合中是否包含 目标数(k)-节点值(root.val)
         if(set.contains(k-root.val)){
             return true;
         }

         //将当前节点值存进集合
         set.add(root.val);

         //对本树的左右节点进行判断，递归
         return find(root.left, k, set) || find(root.right, k, set);
     }
 }